Add thoughts timeline: capture, store, search & broadcast Claude thinking blocks

plugin/hooks/hooks.json

@@ -81,6 +81,11 @@
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/bun-runner.js\" \"${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs\" hook claude-code summarize",
             "timeout": 120
           },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/bun-runner.js\" \"${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs\" hook claude-code thoughts-extract",
+            "timeout": 60
+          },
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/bun-runner.js\" \"${CLAUDE_PLUGIN_ROOT}/scripts/worker-service.cjs\" hook claude-code session-complete",

src/cli/handlers/index.ts

@@ -13,12 +13,14 @@ import { summarizeHandler } from './summarize.js';
 import { userMessageHandler } from './user-message.js';
 import { fileEditHandler } from './file-edit.js';
 import { sessionCompleteHandler } from './session-complete.js';
+import { thoughtsExtractHandler } from './thoughts-extract.js';
 
 export type EventType =
   | 'context'           // SessionStart - inject context
   | 'session-init'      // UserPromptSubmit - initialize session
   | 'observation'       // PostToolUse - save observation
   | 'summarize'         // Stop - generate summary (phase 1)
+  | 'thoughts-extract'  // Stop - extract thinking blocks (phase 1.5)
   | 'session-complete'  // Stop - complete session (phase 2) - fixes #842
   | 'user-message'      // SessionStart (parallel) - display to user
   | 'file-edit';        // Cursor afterFileEdit
@@ -28,6 +30,7 @@ const handlers: Record<EventType, EventHandler> = {
   'session-init': sessionInitHandler,
   'observation': observationHandler,
   'summarize': summarizeHandler,
+  'thoughts-extract': thoughtsExtractHandler,
   'session-complete': sessionCompleteHandler,
   'user-message': userMessageHandler,
   'file-edit': fileEditHandler
@@ -64,3 +67,4 @@ export { summarizeHandler } from './summarize.js';
 export { userMessageHandler } from './user-message.js';
 export { fileEditHandler } from './file-edit.js';
 export { sessionCompleteHandler } from './session-complete.js';
+export { thoughtsExtractHandler } from './thoughts-extract.js';

src/cli/handlers/thoughts-extract.ts

@@ -0,0 +1,50 @@
+/**
+ * Thoughts Extract Handler - Stop (Phase 1.5)
+ *
+ * Extracts thinking blocks from the transcript and stores them via the worker API.
+ * Runs AFTER summarize and BEFORE session-complete in the Stop hook chain.
+ */
+
+import type { EventHandler, NormalizedHookInput, HookResult } from '../types.js';
+import { handleThoughtsExtraction } from '../../hooks/handlers/thoughts.js';
+import { logger } from '../../utils/logger.js';
+import { HOOK_EXIT_CODES } from '../../shared/hook-constants.js';
+
+export const thoughtsExtractHandler: EventHandler = {
+  async execute(input: NormalizedHookInput): Promise<HookResult> {
+    const { sessionId, transcriptPath } = input;
+
+    if (!transcriptPath) {
+      logger.warn('HOOK', 'thoughts-extract: Missing transcriptPath, skipping');
+      return { continue: true, suppressOutput: true, exitCode: HOOK_EXIT_CODES.SUCCESS };
+    }
+
+    if (!sessionId) {
+      logger.warn('HOOK', 'thoughts-extract: Missing sessionId, skipping');
+      return { continue: true, suppressOutput: true, exitCode: HOOK_EXIT_CODES.SUCCESS };
+    }
+
+    try {
+      // handleThoughtsExtraction extracts thinking blocks from the transcript
+      // and sends them to POST /api/sessions/thoughts on the worker.
+      // The worker endpoint resolves memorySessionId and project from contentSessionId.
+      const result = await handleThoughtsExtraction({
+        transcriptPath,
+        sessionId,
+        memorySessionId: '',
+        project: '',
+      });
+
+      logger.info('HOOK', `thoughts-extract: Stored ${result.thoughtsStored} thoughts`, {
+        contentSessionId: sessionId
+      });
+    } catch (error) {
+      // Log but don't fail - thoughts extraction should never block session completion
+      logger.warn('HOOK', 'thoughts-extract: Error extracting thoughts', {
+        error: (error as Error).message
+      });
+    }
+
+    return { continue: true, suppressOutput: true, exitCode: HOOK_EXIT_CODES.SUCCESS };
+  }
+};

src/hooks/handlers/thinking.ts

@@ -0,0 +1,51 @@
+import { readFileSync, existsSync } from 'fs';
+import { logger } from '../../utils/logger.js';
+import type { ThinkingContent } from '../../types/transcript.js';
+
+export interface ThinkingBlock {
+  thinking: string;
+  timestamp: number;
+  messageIndex: number;
+}
+
+/**
+ * Extract thinking blocks from a Claude Code JSONL transcript file.
+ * Reads line-by-line, parses each as JSON, and collects thinking content
+ * from assistant messages.
+ */
+export function extractThinkingBlocks(transcriptPath: string): ThinkingBlock[] {
+  if (!transcriptPath || !existsSync(transcriptPath)) {
+    return [];
+  }
+
+  const content = readFileSync(transcriptPath, 'utf-8').trim();
+  if (!content) {
+    return [];
+  }
+
+  const lines = content.split('\n');
+  const thinkingBlocks: ThinkingBlock[] = [];
+
+  lines.forEach((line, lineIndex) => {
+    try {
+      const entry = JSON.parse(line);
+
+      if (entry.type !== 'assistant') return;
+      if (!Array.isArray(entry.message?.content)) return;
+
+      for (const block of entry.message.content) {
+        if (block.type === 'thinking' && block.thinking) {
+          thinkingBlocks.push({
+            thinking: (block as ThinkingContent).thinking,
+            timestamp: entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now(),
+            messageIndex: lineIndex,
+          });
+        }
+      }
+    } catch {
+      logger.debug('THINKING', 'Skipping malformed transcript line', { lineIndex, transcriptPath });
+    }
+  });
+
+  return thinkingBlocks;
+}

src/hooks/handlers/thoughts.ts

@@ -0,0 +1,84 @@
+import { extractThinkingBlocks } from './thinking.js';
+import { fetchWithTimeout, getWorkerPort, ensureWorkerRunning } from '../../shared/worker-utils.js';
+import { logger } from '../../utils/logger.js';
+import { HOOK_TIMEOUTS, getTimeout } from '../../shared/hook-constants.js';
+import type { ThoughtInput } from '../../services/sqlite/thoughts/types.js';
+
+export interface ThoughtsExtractionInput {
+  transcriptPath: string;
+  sessionId: string;
+  memorySessionId: string;
+  project: string;
+}
+
+export interface ThoughtsExtractionResult {
+  thoughtsStored: number;
+}
+
+const THOUGHTS_TIMEOUT_MS = getTimeout(HOOK_TIMEOUTS.DEFAULT);
+
+/**
+ * Extract thinking blocks from a transcript and store them via the worker API.
+ * Called during the Stop hook to persist Claude's internal reasoning.
+ */
+export async function handleThoughtsExtraction(
+  input: ThoughtsExtractionInput
+): Promise<ThoughtsExtractionResult> {
+  const blocks = extractThinkingBlocks(input.transcriptPath);
+
+  if (blocks.length === 0) {
+    logger.debug('THOUGHTS', 'No thinking blocks found in transcript', {
+      transcriptPath: input.transcriptPath
+    });
+    return { thoughtsStored: 0 };
+  }
+
+  const thoughts: ThoughtInput[] = blocks.map(block => ({
+    thinking_text: block.thinking,
+    thinking_summary: null,
+    message_index: block.messageIndex,
+  }));
+
+  logger.info('THOUGHTS', `Extracted ${thoughts.length} thinking blocks, sending to worker`, {
+    contentSessionId: input.sessionId,
+    project: input.project
+  });
+
+  const workerReady = await ensureWorkerRunning();
+  if (!workerReady) {
+    logger.warn('THOUGHTS', 'Worker not available, skipping thought storage');
+    return { thoughtsStored: 0 };
+  }
+
+  const port = getWorkerPort();
+  const response = await fetchWithTimeout(
+    `http://127.0.0.1:${port}/api/sessions/thoughts`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        memorySessionId: input.memorySessionId,
+        contentSessionId: input.sessionId,
+        project: input.project,
+        thoughts,
+      }),
+    },
+    THOUGHTS_TIMEOUT_MS
+  );
+
+  if (!response.ok) {
+    const text = await response.text();
+    logger.warn('THOUGHTS', 'Failed to store thoughts', {
+      status: response.status,
+      body: text
+    });
+    return { thoughtsStored: 0 };
+  }
+
+  const result = await response.json() as { ids: number[] };
+  logger.info('THOUGHTS', `Stored ${result.ids.length} thoughts`, {
+    contentSessionId: input.sessionId
+  });
+
+  return { thoughtsStored: result.ids.length };
+}