repoburg 1.3.196 → 1.3.197

package/agent-pane/backend/scripts/backfill-from-jsonl.ts

@@ -0,0 +1,206 @@
+/**
+ * One-off backfill script — reconstruct Claude tool-call item data from the
+ * Claude Code JSONL transcripts.
+ *
+ * The early Claude provider did not capture tool results (stdout/MCP results)
+ * and stored `file_change.changes` as the raw tool input object (crashing the
+ * frontend). This script re-derives the correct `items.data` for existing
+ * `command_execution`, `file_change`, and `mcp_tool_call` rows by replaying
+ * each session's transcript (`~/.claude/projects/<encoded-cwd>/<external_thread_id>.jsonl`)
+ * through the same pure mapping functions used by the live provider.
+ *
+ * Idempotent: re-running only re-derives the same data. Backs up `data.db`
+ * to `data.db.bak` before writing. Reasoning items are NOT backfilled (the
+ * transcript stores signed-empty thinking blocks, not the streamed text).
+ *
+ * Usage:  npx tsx scripts/backfill-from-jsonl.ts [path/to/data.db]
+ */
+
+import Database from 'better-sqlite3';
+import { readFileSync, copyFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { deriveFileChangeData, applyToolResult, type ToolResultLike } from '../src/claude/claude-message-mapper.ts';
+
+interface SessionRow {
+  id: string;
+  cwd: string | null;
+  external_thread_id: string;
+}
+
+interface ItemRow {
+  id: string;
+  external_item_id: string;
+  type: string;
+  data: string | null;
+  external_thread_id: string;
+}
+
+interface TranscriptEntry {
+  name: string;
+  input: Record<string, unknown>;
+  toolResult: ToolResultLike | null;
+  toolUseResult: unknown;
+  isError: boolean;
+}
+
+/** Encode a cwd the way Claude Code names project transcript dirs: '/' → '-'. */
+function encodeCwd(cwd: string): string {
+  return cwd.replace(/\//g, '-');
+}
+
+/** Locate the JSONL transcript for a session. Returns null if not found. */
+function transcriptPath(cwd: string | null, externalThreadId: string): string | null {
+  if (!cwd) return null;
+  const dir = join(homedir(), '.claude', 'projects', encodeCwd(cwd));
+  const file = join(dir, `${externalThreadId}.jsonl`);
+  return existsSync(file) ? file : null;
+}
+
+/** Parse a transcript JSONL and index tool calls by tool_use_id.
+ *  Pairs each assistant `tool_use` block with the later `user` `tool_result`. */
+function buildTranscriptMap(filePath: string): Map<string, TranscriptEntry> {
+  const map = new Map<string, TranscriptEntry>();
+  const lines = readFileSync(filePath, 'utf-8').split('\n');
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let obj: Record<string, unknown>;
+    try {
+      obj = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue; // skip malformed lines
+    }
+
+    const type = obj.type;
+    const message = obj.message as { content?: unknown } | undefined;
+    const content = Array.isArray(message?.content) ? (message!.content as Array<Record<string, unknown>>) : [];
+
+    if (type === 'assistant') {
+      for (const block of content) {
+        if (block && block.type === 'tool_use' && typeof block.id === 'string') {
+          map.set(block.id, {
+            name: String(block.name ?? ''),
+            input: (block.input ?? {}) as Record<string, unknown>,
+            toolResult: null,
+            toolUseResult: null,
+            isError: false,
+          });
+        }
+      }
+    } else if (type === 'user') {
+      const toolUseResult = obj.tool_use_result;
+      for (const block of content) {
+        if (block && block.type === 'tool_result' && typeof block.tool_use_id === 'string') {
+          const entry = map.get(block.tool_use_id);
+          if (entry) {
+            entry.toolResult = block as unknown as ToolResultLike;
+            entry.toolUseResult = toolUseResult;
+            entry.isError = !!block.is_error;
+          }
+        }
+      }
+    }
+  }
+
+  return map;
+}
+
+function main(): void {
+  const dbPath = resolve(process.argv[2] ?? 'data.db');
+  if (!existsSync(dbPath)) {
+    console.error(`Database not found: ${dbPath}`);
+    process.exit(1);
+  }
+
+  // Backup before writing
+  const backupPath = `${dbPath}.bak`;
+  copyFileSync(dbPath, backupPath);
+  console.log(`Backed up ${dbPath} → ${backupPath}`);
+
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+
+  const sessions = db
+    .prepare("SELECT id, cwd, external_thread_id FROM sessions WHERE runtime_type = 'claude' AND external_thread_id IS NOT NULL")
+    .all() as SessionRow[];
+
+  console.log(`Claude sessions with external_thread_id: ${sessions.length}`);
+
+  // Cache transcript maps by external_thread_id.
+  const transcriptCache = new Map<string, Map<string, TranscriptEntry> | null>();
+  for (const s of sessions) {
+    const file = transcriptPath(s.cwd, s.external_thread_id);
+    if (!file) {
+      console.warn(`  no transcript for session ${s.id} (cwd=${s.cwd ?? 'null'})`);
+      transcriptCache.set(s.external_thread_id, null);
+      continue;
+    }
+    console.log(`  transcript: ${file}`);
+    transcriptCache.set(s.external_thread_id, buildTranscriptMap(file));
+  }
+
+  const items = db
+    .prepare(`
+      SELECT i.id, i.external_item_id, i.type, i.data, s.external_thread_id
+      FROM items i
+      JOIN turns t ON i.turn_id = t.id
+      JOIN sessions s ON t.session_id = s.id
+      WHERE s.runtime_type = 'claude'
+        AND i.type IN ('command_execution', 'file_change', 'mcp_tool_call')
+        AND i.external_item_id IS NOT NULL
+    `)
+    .all() as ItemRow[];
+
+  console.log(`Candidate items to patch: ${items.length}`);
+
+  const update = db.prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE id = ?');
+  const now = new Date().toISOString();
+
+  let patched = 0;
+  let skipped = 0;
+  const byType: Record<string, number> = { command_execution: 0, file_change: 0, mcp_tool_call: 0 };
+
+  const tx = db.transaction(() => {
+    for (const item of items) {
+      const tmap = transcriptCache.get(item.external_thread_id);
+      if (!tmap) {
+        skipped++;
+        continue;
+      }
+      const entry = tmap.get(item.external_item_id);
+      if (!entry) {
+        skipped++;
+        continue;
+      }
+
+      const existing = item.data ? (JSON.parse(item.data) as Record<string, unknown>) : {};
+
+      let updatedData: Record<string, unknown>;
+      if (item.type === 'file_change') {
+        // Re-derive the canonical changes array from the tool_use input.
+        updatedData = { ...deriveFileChangeData(entry.input, entry.name), status: entry.isError ? 'failed' : 'completed' };
+      } else {
+        updatedData = applyToolResult(item.type, existing, entry.toolResult, entry.toolUseResult, entry.isError);
+      }
+
+      const status = entry.isError ? 'failed' : 'completed';
+      update.run(JSON.stringify(updatedData), status, now, item.id);
+      patched++;
+      byType[item.type] = (byType[item.type] ?? 0) + 1;
+    }
+  });
+  tx();
+
+  console.log('---');
+  console.log(`Patched: ${patched}`);
+  console.log(`  command_execution: ${byType.command_execution ?? 0}`);
+  console.log(`  file_change: ${byType.file_change ?? 0}`);
+  console.log(`  mcp_tool_call: ${byType.mcp_tool_call ?? 0}`);
+  console.log(`Skipped (no matching tool_use_id): ${skipped}`);
+  console.log(`Backup at: ${backupPath}`);
+
+  db.close();
+}
+
+main();

package/agent-pane/backend/scripts/import-session-from-jsonl.ts

@@ -0,0 +1,264 @@
+/**
+ * One-off import script — build a clean agent-pane session from a Claude Code
+ * JSONL transcript, replaying it through the (fixed) Claude mapper logic.
+ *
+ * Unlike `backfill-from-jsonl.ts` (which patches existing items by tool_use_id),
+ * this creates a FRESH session + turns + items from the transcript, so every
+ * tool_use/tool_result is captured with its output — no reliance on the broken
+ * historical provider data.
+ *
+ * Idempotent: the imported session uses a deterministic id (`imported-<sessionId>`);
+ * re-running skips if it already exists. Existing sessions are never touched.
+ *
+ * Reasoning: the transcript stores signed-empty `thinking` blocks (the real text
+ * was streamed via `thinking_delta`, which the transcript does not keep), so
+ * reasoning items are only created when a block has non-empty thinking text.
+ *
+ * Usage:  npx tsx scripts/import-session-from-jsonl.ts [path/to/transcript.jsonl]
+ */
+
+import Database from 'better-sqlite3';
+import { readFileSync, existsSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
+import {
+  deriveFileChangeData,
+  applyToolResult,
+  type ToolResultLike,
+} from '../src/claude/claude-message-mapper.ts';
+
+const DB_PATH = resolve('data.db');
+const DEFAULT_TRANSCRIPT =
+  '/Users/celal/.claude/projects/-Users-celal-inkind/3a572d87-bb45-41de-9fae-5a05b537f137.jsonl';
+const DEFAULT_CWD = '/Users/celal/inkind';
+
+interface ParsedItem {
+  type: string;
+  externalId: string;
+  data: Record<string, unknown>;
+  status: string;
+  createdAt: string;
+}
+
+interface Turn {
+  id: string;
+  userPrompt: string;
+  items: Map<string, ParsedItem>; // externalId -> item (tool items)
+  orderedItems: ParsedItem[];
+  agentResponse: string | null;
+  thoughts: string | null;
+  tokenUsage: unknown;
+  createdAt: string;
+}
+
+/** Extract a user prompt string from a user message's content (text-only, no tool_result). */
+function userPromptText(content: unknown): string | null {
+  if (typeof content === 'string') {
+    return content.startsWith('<') || content.startsWith('[Request') ? null : content;
+  }
+  if (Array.isArray(content)) {
+    const texts: string[] = [];
+    let hasToolResult = false;
+    for (const b of content) {
+      if (typeof b !== 'object' || b === null) continue;
+      const block = b as Record<string, unknown>;
+      if (block.type === 'tool_result') hasToolResult = true;
+      if (block.type === 'text') texts.push(String(block.text ?? ''));
+    }
+    if (hasToolResult) return null; // tool-result message, not a new turn
+    return texts.join('\n').trim() || null;
+  }
+  return null;
+}
+
+function main(): void {
+  const transcriptPath = resolve(process.argv[2] ?? DEFAULT_TRANSCRIPT);
+  const dbPath = resolve(process.argv[3] ?? DB_PATH);
+  if (!existsSync(transcriptPath)) {
+    console.error(`Transcript not found: ${transcriptPath}`);
+    process.exit(1);
+  }
+  if (!existsSync(dbPath)) {
+    console.error(`Database not found: ${dbPath}`);
+    process.exit(1);
+  }
+
+  const sessionId = `imported-${transcriptPath.split('/').pop()!.replace('.jsonl', '')}`;
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+
+  // Idempotency: skip if already imported.
+  const existing = db.prepare('SELECT id FROM sessions WHERE id = ?').get(sessionId);
+  if (existing) {
+    console.log(`Session already imported (id=${sessionId}). Skipping. Delete it first to re-import.`);
+    db.close();
+    return;
+  }
+
+  const lines = readFileSync(transcriptPath, 'utf-8').split('\n');
+  let aiTitle = '';
+  const turns: Turn[] = [];
+  let current: Turn | null = null;
+  let firstTimestamp: string | null = null;
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    let obj: Record<string, unknown>;
+    try {
+      obj = JSON.parse(line) as Record<string, unknown>;
+    } catch {
+      continue;
+    }
+
+    const ts = (obj.timestamp as string) ?? new Date().toISOString();
+    if (!firstTimestamp) firstTimestamp = ts;
+
+    // Metadata / summary line carries aiTitle.
+    if (typeof obj.aiTitle === 'string' && !aiTitle) aiTitle = obj.aiTitle as string;
+
+    const type = obj.type;
+    const message = obj.message as { content?: unknown } | undefined;
+    const content = message?.content;
+
+    if (type === 'user') {
+      const prompt = userPromptText(content);
+      if (prompt !== null) {
+        // New turn boundary.
+        if (current) turns.push(current);
+        current = { id: randomUUID(), userPrompt: prompt, items: new Map(), orderedItems: [], agentResponse: null, thoughts: null, tokenUsage: null, createdAt: ts };
+        continue;
+      }
+      // Tool-result message — apply to the current turn's items.
+      if (current && Array.isArray(content)) {
+        for (const b of content) {
+          if (typeof b !== 'object' || b === null) continue;
+          const block = b as Record<string, unknown>;
+          if (block.type !== 'tool_result' || typeof block.tool_use_id !== 'string') continue;
+          const item = current.items.get(block.tool_use_id);
+          if (!item) continue;
+          const isError = !!block.is_error;
+          item.data = applyToolResult(item.type, item.data, block as unknown as ToolResultLike, obj.tool_use_result, isError);
+          item.status = isError ? 'failed' : 'completed';
+          item.data.status = item.status;
+        }
+      }
+      continue;
+    }
+
+    if (type === 'assistant' && current && Array.isArray(content)) {
+      for (const b of content) {
+        if (typeof b !== 'object' || b === null) continue;
+        const block = b as Record<string, unknown>;
+        if (block.type === 'text') {
+          const text = String(block.text ?? '');
+          if (!text.trim()) continue;
+          const item: ParsedItem = { type: 'agent_message', externalId: randomUUID(), data: { text }, status: 'completed', createdAt: ts };
+          current.orderedItems.push(item);
+          current.agentResponse = text;
+        } else if (block.type === 'thinking') {
+          const text = String(block.thinking ?? '');
+          if (!text.trim()) continue; // signed-empty blocks: skip (no real text in transcript)
+          const item: ParsedItem = { type: 'reasoning', externalId: randomUUID(), data: { text }, status: 'completed', createdAt: ts };
+          current.orderedItems.push(item);
+          current.thoughts = text;
+        } else if (block.type === 'tool_use' && typeof block.id === 'string') {
+          const input = (block.input ?? {}) as Record<string, unknown>;
+          const name = String(block.name ?? '');
+          let type: string;
+          let data: Record<string, unknown>;
+          if (name === 'Bash') {
+            type = 'command_execution';
+            data = { command: input.command ?? '', aggregated_output: null, exit_code: null, status: 'in_progress' };
+          } else if (name === 'Edit' || name === 'Write' || name === 'MultiEdit' || name === 'NotebookEdit') {
+            type = 'file_change';
+            data = deriveFileChangeData(input, name);
+          } else {
+            type = 'mcp_tool_call';
+            data = { server: null, tool: name, arguments: input, result: null, error: null, status: 'in_progress' };
+          }
+          const item: ParsedItem = { type, externalId: block.id, data, status: 'in_progress', createdAt: ts };
+          current.orderedItems.push(item);
+          current.items.set(block.id, item);
+        }
+      }
+      continue;
+    }
+
+    if (type === 'result' && current) {
+      const usage = (obj as Record<string, unknown>).usage;
+      if (usage && typeof usage === 'object') current.tokenUsage = usage;
+    }
+  }
+  if (current) turns.push(current);
+
+  if (turns.length === 0) {
+    console.error('No turns found in transcript.');
+    db.close();
+    process.exit(1);
+  }
+
+  // Persist in a single transaction.
+  const insertSession = db.prepare(`
+    INSERT INTO sessions (id, title, runtime_type, model, cwd, external_thread_id, status, is_running, lifecycle, has_unreviewed, created_at, updated_at)
+    VALUES (?, ?, 'claude', ?, ?, ?, 'active', 0, 'finished', 0, ?, ?)
+  `);
+  const insertTurn = db.prepare(`
+    INSERT INTO turns (id, session_id, user_prompt, agent_response, thoughts, token_usage, external_turn_id, status, error, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, NULL, 'completed', NULL, ?, ?)
+  `);
+  const insertItem = db.prepare(`
+    INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  const externalThreadId = transcriptPath.split('/').pop()!.replace('.jsonl', '');
+  const sessionCreated = firstTimestamp ?? new Date().toISOString();
+
+  let totalItems = 0;
+  const counts: Record<string, number> = {};
+
+  const tx = db.transaction(() => {
+    insertSession.run(sessionId, aiTitle || null, 'default', DEFAULT_CWD, externalThreadId, sessionCreated, sessionCreated);
+    for (const turn of turns) {
+      insertTurn.run(
+        turn.id,
+        sessionId,
+        turn.userPrompt,
+        turn.agentResponse,
+        turn.thoughts,
+        turn.tokenUsage ? JSON.stringify(turn.tokenUsage) : null,
+        turn.createdAt,
+        turn.createdAt,
+      );
+      for (const item of turn.orderedItems) {
+        const itemId = randomUUID();
+        insertItem.run(
+          itemId,
+          turn.id,
+          item.externalId,
+          item.type,
+          JSON.stringify(item.data),
+          item.status,
+          item.createdAt,
+          item.createdAt,
+        );
+        totalItems++;
+        counts[item.type] = (counts[item.type] ?? 0) + 1;
+      }
+    }
+  });
+  tx();
+
+  console.log('--- import complete ---');
+  console.log(`session id: ${sessionId}`);
+  console.log(`title: ${aiTitle || '(none)'}`);
+  console.log(`external_thread_id: ${externalThreadId}`);
+  console.log(`turns: ${turns.length}`);
+  console.log(`items: ${totalItems}`);
+  for (const [t, n] of Object.entries(counts)) console.log(`  ${t}: ${n}`);
+
+  db.close();
+}
+
+main();

package/agent-pane/backend/src/claude/claude-message-mapper.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { mapAssistantContent, mapPartialDelta, mapUsage } from './claude-message-mapper.ts';
+import { mapAssistantContent, mapPartialDelta, mapUsage, applyToolResult, deriveFileChangeData, extractToolResultText } from './claude-message-mapper.ts';
 
 describe('claude-message-mapper', () => {
   describe('mapAssistantContent', () => {
@@ -19,6 +19,22 @@ describe('claude-message-mapper', () => {
       expect(result[0].data).toEqual({ text: 'I should respond' });
     });
 
+    it('uses thinkingTexts fallback when thinking block is empty (signed-empty)', () => {
+      const content = [{ type: 'thinking', thinking: '', signature: 'sig' }] as never;
+      const thinkingTexts = new Map([[0, 'Accumulated thinking text']]);
+      const result = mapAssistantContent(content, 'msg-1', thinkingTexts);
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe('reasoning');
+      expect(result[0].data).toEqual({ text: 'Accumulated thinking text' });
+    });
+
+    it('keeps empty text when thinkingTexts is not provided', () => {
+      const content = [{ type: 'thinking', thinking: '', signature: 'sig' }] as never;
+      const result = mapAssistantContent(content, 'msg-1');
+      expect(result).toHaveLength(1);
+      expect(result[0].data).toEqual({ text: '' });
+    });
+
     it('maps a Bash tool_use to command_execution', () => {
       const content = [{ type: 'tool_use', id: 'tu-1', name: 'Bash', input: { command: 'ls -la' } }] as never;
       const result = mapAssistantContent(content, 'msg-1');
@@ -33,22 +49,26 @@ describe('claude-message-mapper', () => {
       expect(result[0].externalId).toBe('tu-1');
     });
 
-    it('maps an Edit tool_use to file_change', () => {
-      const content = [{ type: 'tool_use', id: 'tu-2', name: 'Edit', input: { file_path: 'foo.ts' } }] as never;
+    it('maps an Edit tool_use to file_change with canonical changes array', () => {
+      const content = [{ type: 'tool_use', id: 'tu-2', name: 'Edit', input: { file_path: 'foo.ts', old_string: 'a', new_string: 'b' } }] as never;
       const result = mapAssistantContent(content, 'msg-1');
       expect(result).toHaveLength(1);
       expect(result[0].type).toBe('file_change');
       expect(result[0].data).toEqual({
-        changes: { file_path: 'foo.ts' },
+        changes: [{ path: 'foo.ts', kind: 'modify' }],
         status: 'in_progress',
       });
     });
 
-    it('maps a Write tool_use to file_change', () => {
-      const content = [{ type: 'tool_use', id: 'tu-3', name: 'Write', input: { file_path: 'bar.ts' } }] as never;
+    it('maps a Write tool_use to file_change with kind "add"', () => {
+      const content = [{ type: 'tool_use', id: 'tu-3', name: 'Write', input: { file_path: 'bar.ts', content: 'x' } }] as never;
       const result = mapAssistantContent(content, 'msg-1');
       expect(result).toHaveLength(1);
       expect(result[0].type).toBe('file_change');
+      expect(result[0].data).toEqual({
+        changes: [{ path: 'bar.ts', kind: 'add' }],
+        status: 'in_progress',
+      });
     });
 
     it('maps an unknown tool_use to mcp_tool_call', () => {
@@ -92,6 +112,94 @@ describe('claude-message-mapper', () => {
     });
   });
 
+  describe('deriveFileChangeData', () => {
+    it('maps an Edit input to a single modify change', () => {
+      expect(deriveFileChangeData({ file_path: 'a.ts', old_string: 'x', new_string: 'y' }, 'Edit')).toEqual({
+        changes: [{ path: 'a.ts', kind: 'modify' }],
+        status: 'in_progress',
+      });
+    });
+
+    it('maps a Write input to an add change', () => {
+      expect(deriveFileChangeData({ file_path: 'b.ts', content: 'x' }, 'Write')).toEqual({
+        changes: [{ path: 'b.ts', kind: 'add' }],
+        status: 'in_progress',
+      });
+    });
+
+    it('falls back to notebook_path and defaults kind to modify', () => {
+      expect(deriveFileChangeData({ notebook_path: 'nb.ipynb' }, 'NotebookEdit')).toEqual({
+        changes: [{ path: 'nb.ipynb', kind: 'modify' }],
+        status: 'in_progress',
+      });
+    });
+
+    it('uses empty string when no path field present', () => {
+      expect(deriveFileChangeData({}, 'MultiEdit')).toEqual({
+        changes: [{ path: '', kind: 'modify' }],
+        status: 'in_progress',
+      });
+    });
+  });
+
+  describe('extractToolResultText', () => {
+    it('returns a string content as-is', () => {
+      expect(extractToolResultText('hello')).toBe('hello');
+    });
+    it('joins text blocks in an array', () => {
+      expect(extractToolResultText([{ type: 'text', text: 'a' }, { type: 'text', text: 'b' }])).toBe('a\nb');
+    });
+    it('ignores non-text blocks', () => {
+      expect(extractToolResultText([{ type: 'tool_reference', tool_name: 'x' }, { type: 'text', text: 'a' }])).toBe('a');
+    });
+    it('returns empty for null/undefined', () => {
+      expect(extractToolResultText(null)).toBe('');
+      expect(extractToolResultText(undefined)).toBe('');
+    });
+  });
+
+  describe('applyToolResult', () => {
+    it('command_execution: fills aggregated_output from structured stdout+stderr and exit_code from is_error', () => {
+      const existing = { command: 'ls', aggregated_output: null, exit_code: null, status: 'in_progress' };
+      const out = applyToolResult('command_execution', existing, { tool_use_id: 't1', content: 'file1\nfile2' }, { stdout: 'file1\nfile2', stderr: 'warn', interrupted: false, isImage: false, noOutputExpected: false }, false);
+      expect(out).toEqual({ command: 'ls', aggregated_output: 'file1\nfile2\nwarn', exit_code: 0, status: 'completed' });
+    });
+
+    it('command_execution: marks failed and exit_code 1 on error', () => {
+      const existing = { command: 'bad', aggregated_output: null, exit_code: null, status: 'in_progress' };
+      const out = applyToolResult('command_execution', existing, { tool_use_id: 't2', is_error: true, content: 'boom' }, { stdout: 'boom', stderr: '' }, true);
+      expect(out.exit_code).toBe(1);
+      expect(out.status).toBe('failed');
+      expect(out.aggregated_output).toBe('boom');
+    });
+
+    it('mcp_tool_call: fills result text and no error on success', () => {
+      const existing = { server: null, tool: 'Linear.get', arguments: { id: 'PAR-1' }, result: null, error: null, status: 'in_progress' };
+      const out = applyToolResult('mcp_tool_call', existing, { tool_use_id: 't3', content: [{ type: 'text', text: '{"id":"PAR-1"}' }] }, null, false);
+      expect(out.result).toEqual([{ type: 'text', text: '{"id":"PAR-1"}' }]);
+      expect(out.error).toBeNull();
+      expect(out.status).toBe('completed');
+    });
+
+    it('mcp_tool_call: sets error on is_error', () => {
+      const existing = { server: null, tool: 'X', arguments: {}, result: null, error: null, status: 'in_progress' };
+      const out = applyToolResult('mcp_tool_call', existing, { tool_use_id: 't4', is_error: true, content: 'denied' }, null, true);
+      expect(out.error).toBe('denied');
+      expect(out.status).toBe('failed');
+    });
+
+    it('file_change: keeps existing changes and flips status to completed', () => {
+      const existing = { changes: [{ path: 'a.ts', kind: 'modify' }], status: 'in_progress' };
+      const out = applyToolResult('file_change', existing, { tool_use_id: 't5', content: 'ok' }, null, false);
+      expect(out).toEqual({ changes: [{ path: 'a.ts', kind: 'modify' }], status: 'completed' });
+    });
+
+    it('unknown type: returns existing data unchanged', () => {
+      const existing = { foo: 1 };
+      expect(applyToolResult('agent_message', existing, null, null, false)).toEqual({ foo: 1 });
+    });
+  });
+
   describe('mapPartialDelta', () => {
     it('maps a text_delta event', () => {
       const event = {
@@ -100,7 +208,7 @@ describe('claude-message-mapper', () => {
         index: 0,
       };
       const result = mapPartialDelta(event);
-      expect(result).toEqual({ kind: 'text', text: 'Hello' });
+      expect(result).toEqual({ kind: 'text', text: 'Hello', index: 0 });
     });
 
     it('maps a thinking_delta event', () => {
@@ -110,7 +218,7 @@ describe('claude-message-mapper', () => {
         index: 0,
       };
       const result = mapPartialDelta(event);
-      expect(result).toEqual({ kind: 'thinking', text: 'Hmm' });
+      expect(result).toEqual({ kind: 'thinking', text: 'Hmm', index: 0 });
     });
 
     it('returns null for non-delta events', () => {