feat: add post-commit hook for automatic session notes (GIT-74)

src/application/handlers/PostCommitHandler.ts

@@ -0,0 +1,121 @@
+/**
+ * PostCommitHandler
+ *
+ * Handles the git:commit event by writing session metadata as a git note.
+ * Preserves any existing memories on the commit while adding/updating
+ * the session field with agent, model, and timestamp.
+ */
+
+import type { IPostCommitHandler } from '../interfaces/IPostCommitHandler';
+import type { IGitCommitEvent } from '../../domain/events/HookEvents';
+import type { IEventResult } from '../../domain/interfaces/IEventResult';
+import type { INotesService } from '../../domain/interfaces/INotesService';
+import type { ILogger } from '../../domain/interfaces/ILogger';
+import { resolveAgent, resolveModel } from '../../infrastructure/detect-agent';
+
+/**
+ * Session metadata stored in the note's `session` field.
+ */
+interface ISessionMetadata {
+  agent: string;
+  model?: string;
+  timestamp: string;
+}
+
+/**
+ * Note payload structure.
+ * The `memories` array is managed by MemoryRepository.
+ * The `session` field is managed by this handler.
+ */
+interface INotePayload {
+  memories?: unknown[];
+  session?: ISessionMetadata;
+}
+
+export class PostCommitHandler implements IPostCommitHandler {
+  constructor(
+    private readonly notesService: INotesService,
+    private readonly logger?: ILogger,
+  ) {}
+
+  async handle(event: IGitCommitEvent): Promise<IEventResult> {
+    try {
+      const agent = resolveAgent();
+      const model = resolveModel();
+
+      // No agent detected — exit silently (not an AI-assisted commit)
+      if (!agent) {
+        this.logger?.debug('No AI agent detected, skipping session note');
+        return {
+          handler: 'PostCommitHandler',
+          success: true,
+        };
+      }
+
+      this.logger?.info('Post-commit handler invoked', {
+        sha: event.sha,
+        agent,
+        model,
+      });
+
+      // Read existing note payload
+      const payload = this.readPayload(event.sha, event.cwd);
+
+      // Add/update session metadata
+      payload.session = {
+        agent,
+        model,
+        timestamp: new Date().toISOString(),
+      };
+
+      // Write back
+      this.writePayload(event.sha, payload, event.cwd);
+
+      this.logger?.info('Session note written', {
+        sha: event.sha,
+        hasMemories: Array.isArray(payload.memories) && payload.memories.length > 0,
+      });
+
+      return {
+        handler: 'PostCommitHandler',
+        success: true,
+      };
+    } catch (error) {
+      this.logger?.error('Post-commit handler failed', { error });
+      return {
+        handler: 'PostCommitHandler',
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error)),
+      };
+    }
+  }
+
+  /**
+   * Read and parse the existing note payload.
+   * Returns empty object if no note exists or parsing fails.
+   */
+  private readPayload(sha: string, cwd: string): INotePayload {
+    const raw = this.notesService.read(sha, undefined, cwd);
+    if (!raw) return {};
+
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed === 'object' && parsed !== null) {
+        return parsed as INotePayload;
+      }
+      return {};
+    } catch {
+      // Malformed JSON — return empty and let write overwrite
+      this.logger?.warn('Malformed note JSON, will overwrite', { sha });
+      return {};
+    }
+  }
+
+  /**
+   * Serialize and write the payload to the note.
+   */
+  private writePayload(sha: string, payload: INotePayload, cwd: string): void {
+    const json = JSON.stringify(payload, null, 2);
+    this.notesService.write(sha, json, undefined, cwd);
+  }
+}

src/application/interfaces/IPostCommitHandler.ts

@@ -0,0 +1,10 @@
+/**
+ * IPostCommitHandler
+ *
+ * Application interface for the post-commit hook handler.
+ */
+
+import type { IEventHandler } from '../../domain/interfaces/IEventHandler';
+import type { IGitCommitEvent } from '../../domain/events/HookEvents';
+
+export type IPostCommitHandler = IEventHandler<IGitCommitEvent>;

src/commands/hook.ts

@@ -24,21 +24,24 @@ export interface IHookInput {
   prompt?: string;
   cwd?: string;
   hook_event_name?: string;
+  sha?: string;
 }
 
 /** Map CLI event names to internal event bus types. */
 export const EVENT_MAP: Record<string, HookEventType> = {
   'session-start': 'session:start',
   'session-stop': 'session:stop',
   'prompt-submit': 'prompt:submit',
+  'post-commit': 'git:commit',
 };
 
 /** Map CLI event names to the config section that controls them. */
-type ConfigKey = 'sessionStart' | 'sessionStop' | 'promptSubmit';
+type ConfigKey = 'sessionStart' | 'sessionStop' | 'promptSubmit' | 'postCommit';
 const CONFIG_KEY_MAP: Record<string, ConfigKey> = {
   'session-start': 'sessionStart',
   'session-stop': 'sessionStop',
   'prompt-submit': 'promptSubmit',
+  'post-commit': 'postCommit',
 };
 
 /** Extra enabled check for session-stop (must also have autoExtract). */
@@ -73,6 +76,8 @@ export function buildEvent(eventType: HookEventType, input: IHookInput): HookEve
       return { type: 'session:stop', ...base };
     case 'prompt:submit':
       return { type: 'prompt:submit', ...base, prompt: input.prompt ?? '' };
+    case 'git:commit':
+      return { type: 'git:commit', sha: input.sha ?? 'HEAD', cwd: base.cwd };
     default: {
       const exhaustiveCheck: never = eventType;
       throw new Error(`Unhandled HookEventType in buildEvent: ${exhaustiveCheck as string}`);
@@ -85,6 +90,7 @@ const STDERR_LABELS: Record<HookEventType, { success: string; prefix: string }>
   'session:start': { success: 'Memory loaded.', prefix: 'Memory loaded' },
   'session:stop': { success: 'Session capture complete.', prefix: 'Session capture complete' },
   'prompt:submit': { success: 'Prompt context loaded.', prefix: 'Prompt context loaded' },
+  'git:commit': { success: 'Session note written.', prefix: 'Session note' },
 };
 
 export async function hookCommand(eventName: string, _logger?: ILogger): Promise<void> {

src/commands/init-hooks.ts

@@ -204,6 +204,9 @@ export function buildGitMemConfig(): Record<string, unknown> {
         recordPrompts: false,
         surfaceContext: true,
       },
+      postCommit: {
+        enabled: true,
+      },
     },
   };
 }

src/commands/init.ts

@@ -19,6 +19,7 @@ import {
 } from './init-hooks';
 import { buildMcpConfig } from './init-mcp';
 import { installHook, uninstallHook } from '../hooks/prepare-commit-msg';
+import { installPostCommitHook, uninstallPostCommitHook } from '../hooks/post-commit';
 import { createContainer } from '../infrastructure/di';
 import { createStderrProgressHandler } from './progress';
 
@@ -120,11 +121,17 @@ export async function initCommand(options: IInitCommandOptions, logger?: ILogger
 
   // ── Git hook uninstall (early exit) ─────────────────────────────
   if (options.uninstallHooks) {
-    const removed = uninstallHook(cwd);
-    if (removed) {
+    const removedPrepare = uninstallHook(cwd);
+    const removedPost = uninstallPostCommitHook(cwd);
+
+    if (removedPrepare) {
       console.log('✓ Removed prepare-commit-msg hook');
-    } else {
-      console.log('No git-mem prepare-commit-msg hook found.');
+    }
+    if (removedPost) {
+      console.log('✓ Removed post-commit hook');
+    }
+    if (!removedPrepare && !removedPost) {
+      console.log('No git-mem hooks found.');
     }
     return;
   }
@@ -200,14 +207,21 @@ export async function initCommand(options: IInitCommandOptions, logger?: ILogger
     console.log('✓ Created .git-mem.json');
   }
 
-  // ── Git hook (prepare-commit-msg) ─────────────────────────────
+  // ── Git hooks (prepare-commit-msg + post-commit) ─────────────────
   if (options.hooks) {
-    const hookResult = installHook(cwd);
-    if (hookResult.installed) {
-      console.log(`✓ Installed prepare-commit-msg hook${hookResult.wrapped ? ' (wrapped existing hook)' : ''}`);
+    const prepareResult = installHook(cwd);
+    if (prepareResult.installed) {
+      console.log(`✓ Installed prepare-commit-msg hook${prepareResult.wrapped ? ' (wrapped existing hook)' : ''}`);
     } else {
       console.log('✓ prepare-commit-msg hook already installed (skipped)');
     }
+
+    const postResult = installPostCommitHook(cwd);
+    if (postResult.installed) {
+      console.log(`✓ Installed post-commit hook${postResult.wrapped ? ' (wrapped existing hook)' : ''}`);
+    } else {
+      console.log('✓ post-commit hook already installed (skipped)');
+    }
   }
 
   // ── MCP config (skip if already exists) ────────────────────────

src/domain/events/HookEvents.ts

@@ -33,8 +33,17 @@ export interface IPromptSubmitEvent {
   readonly cwd: string;
 }
 
+/** Event emitted after a git commit is created. */
+export interface IGitCommitEvent {
+  readonly type: 'git:commit';
+  /** The commit SHA. */
+  readonly sha: string;
+  /** Working directory of the repository. */
+  readonly cwd: string;
+}
+
 /** Union of all hook events. */
-export type HookEvent = ISessionStartEvent | ISessionStopEvent | IPromptSubmitEvent;
+export type HookEvent = ISessionStartEvent | ISessionStopEvent | IPromptSubmitEvent | IGitCommitEvent;
 
 /** String literal union of all hook event types. */
 export type HookEventType = HookEvent['type'];

src/domain/interfaces/IHookConfig.ts

@@ -31,11 +31,16 @@ export interface IPromptSubmitConfig {
   readonly surfaceContext: boolean;
 }
 
+export interface IPostCommitConfig {
+  readonly enabled: boolean;
+}
+
 export interface IHooksConfig {
   readonly enabled: boolean;
   readonly sessionStart: ISessionStartConfig;
   readonly sessionStop: ISessionStopConfig;
   readonly promptSubmit: IPromptSubmitConfig;
+  readonly postCommit: IPostCommitConfig;
 }
 
 export interface IHookConfig {