repoburg 1.3.198 → 1.3.201

package/agent-pane/backend/src/claude/claude-provider.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
 // Mock the SDK query function
 vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
@@ -7,13 +7,29 @@ vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
 
 import { query } from '@anthropic-ai/claude-agent-sdk';
 
-// Import after mock is set up
-import { claudeProvider, clearAllThreads } from './claude-provider.ts';
+// Capture broadcasts without touching a real WebSocket server.
+const captured: Array<{ event: string; data: unknown }> = [];
+vi.mock('../ws/index.ts', async (importOriginal) => {
+  const actual = (await importOriginal()) as Record<string, unknown>;
+  return {
+    ...actual,
+    broadcast: vi.fn((event: string, data: unknown) => {
+      captured.push({ event, data });
+    }),
+  };
+});
+
+// Import after mocks are set up
+import { claudeProvider, clearAllThreads, handleResultMessage, handleMessage } from './claude-provider.ts';
+import { initDb } from '../db/index.ts';
+import type Database from 'better-sqlite3';
+import type { ClaudeSessionEntry } from './claude-types.ts';
 
 describe('claudeProvider', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     clearAllThreads();
+    captured.length = 0;
   });
 
   it('implements all RuntimeProvider methods', () => {
@@ -62,4 +78,378 @@ describe('claudeProvider', () => {
   it('shutdown does not throw', async () => {
     await expect(claudeProvider.shutdown()).resolves.not.toThrow();
   });
+});
+
+/** Build a mock ClaudeSessionEntry whose query.getContextUsage() returns the given snapshot. */
+function makeEntry(getContextUsage: ReturnType<typeof vi.fn>): ClaudeSessionEntry {
+  return {
+    query: {
+      getContextUsage,
+      interrupt: vi.fn(),
+      setModel: vi.fn(),
+      close: vi.fn(),
+      stopTask: vi.fn(),
+      initializationResult: vi.fn(),
+      [Symbol.asyncIterator]: async function* () {},
+    } as never,
+    sessionId: 'cs_test',
+    turnId: null,
+    cwd: '/test',
+    promptQueue: { push: vi.fn(), close: vi.fn() } as never,
+    messageLoop: null,
+  };
+}
+
+/** Build a result/success SDK message with the given (accumulated) token usage. */
+function makeResultMessage(usage: {
+  input_tokens: number;
+  cache_read_input_tokens: number;
+  cache_creation_input_tokens: number;
+  output_tokens: number;
+}): unknown {
+  return {
+    type: 'result',
+    subtype: 'success',
+    usage,
+    modelUsage: {},
+    result: 'done',
+    is_error: false,
+    num_turns: 1,
+    stop_reason: 'end_turn',
+    duration_ms: 100,
+    duration_api_ms: 100,
+    total_cost_usd: 0,
+    permission_denials: [],
+    uuid: 'u1',
+    session_id: 'cs_test',
+  };
+}
+
+describe('handleResultMessage — context-window usage', () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = initDb(':memory:');
+    // Session with a non-null title so syncThreadTitle short-circuits (no title query).
+    db.prepare(
+      `INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, created_at, updated_at)
+       VALUES ('s1', 'Test', 'claude', 'running', 1, 'working', ?, ?)`,
+    ).run(new Date().toISOString(), new Date().toISOString());
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, status, created_at, updated_at)
+       VALUES ('t1', 's1', 'hi', 'running', ?, ?)`,
+    ).run(new Date().toISOString(), new Date().toISOString());
+    captured.length = 0;
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  it('uses SDK getContextUsage() real fill, NOT the accumulated result.usage sum', async () => {
+    // Old buggy behavior: result.usage sums to 800K (accumulated). getContextUsage reports the real 130K.
+    const getContextUsage = vi.fn().mockResolvedValue({
+      totalTokens: 130000,
+      maxTokens: 1000000,
+      rawMaxTokens: 1000000,
+      percentage: 13,
+      categories: [],
+      gridRows: [],
+      model: 'claude-sonnet',
+      memoryFiles: [],
+      mcpTools: [],
+    });
+    const entry = makeEntry(getContextUsage);
+
+    await handleResultMessage(
+      makeResultMessage({
+        input_tokens: 300000,
+        cache_read_input_tokens: 400000,
+        cache_creation_input_tokens: 100000, // sum = 800K (the wrong accumulated value)
+        output_tokens: 500,
+      }) as never,
+      's1',
+      't1',
+      entry,
+      db,
+    );
+
+    // turn:contextUsage must carry the SDK's real fill (130K), not the 800K sum.
+    const ctx = captured.find((b) => b.event === 'turn:contextUsage');
+    expect(ctx).toBeDefined();
+    expect((ctx!.data as { totalTokens: number }).totalTokens).toBe(130000);
+    expect((ctx!.data as { contextWindow: number }).contextWindow).toBe(1000000);
+    expect((ctx!.data as { percentage: number }).percentage).toBe(13);
+
+    // Persisted to the session row so the counter survives reload.
+    const row = db.prepare('SELECT context_usage FROM sessions WHERE id = ?').get('s1') as
+      | { context_usage: string | null }
+      | undefined;
+    expect(row?.context_usage).toBeTruthy();
+    expect(JSON.parse(row!.context_usage!).totalTokens).toBe(130000);
+  });
+
+  it('does not broadcast a bad value when getContextUsage() rejects', async () => {
+    const getContextUsage = vi.fn().mockRejectedValue(new Error('not available'));
+    const entry = makeEntry(getContextUsage);
+
+    await handleResultMessage(
+      makeResultMessage({
+        input_tokens: 100,
+        cache_read_input_tokens: 0,
+        cache_creation_input_tokens: 0,
+        output_tokens: 10,
+      }) as never,
+      's1',
+      't1',
+      entry,
+      db,
+    );
+
+    expect(captured.find((b) => b.event === 'turn:contextUsage')).toBeUndefined();
+    // The turn still completes normally.
+    expect(captured.find((b) => b.event === 'turn:completed')).toBeDefined();
+  });
+});
+
+describe('handleMessage — system/init must not corrupt main session for thread entries', () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    db = initDb(':memory:');
+    // Main session whose Claude session id is 'main-session-1'.
+    db.prepare(
+      `INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, external_thread_id, created_at, updated_at)
+       VALUES ('s1', 'Test', 'claude', 'active', 0, 'working', 'main-session-1', ?, ?)`,
+    ).run(new Date().toISOString(), new Date().toISOString());
+    captured.length = 0;
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  /** Build a minimal entry for init-handler tests (getContextUsage unused). */
+  function makeInitEntry(): ClaudeSessionEntry {
+    return makeEntry(vi.fn());
+  }
+
+  /** Build a system/init SDK message with the given Claude session id. */
+  function makeInitMessage(claudeSessionId: string): unknown {
+    return { type: 'system', subtype: 'init', session_id: claudeSessionId };
+  }
+
+  it('thread entry: sets entry.sessionId but does NOT overwrite the main session external_thread_id', async () => {
+    // Regression: the system/init handler previously wrote the forked session's
+    // id into the MAIN session's external_thread_id for ALL entries, because
+    // handleMessage is always called with the main session id and entry.threadId
+    // was never populated. After a restart/rewind the main session would resume
+    // the fork and "remember" the thread's discussion.
+    const entry = makeInitEntry();
+    entry.threadId = 'thread-1';
+
+    await handleMessage(
+      makeInitMessage('fork-session-9') as never,
+      's1', // main session id — passed to handleMessage for ALL entries
+      't1',
+      entry,
+      db,
+    );
+
+    // entry.sessionId is captured (needed for Monitor output-path construction).
+    expect(entry.sessionId).toBe('fork-session-9');
+    // The main session's resume id is NOT corrupted with the fork's id.
+    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(row?.external_thread_id).toBe('main-session-1');
+  });
+
+  it('main entry: still persists external_thread_id (preserves existing behavior)', async () => {
+    const entry = makeInitEntry();
+    entry.threadId = null; // main session entry (not a thread/fork)
+
+    await handleMessage(
+      makeInitMessage('fork-session-9') as never,
+      's1',
+      't1',
+      entry,
+      db,
+    );
+
+    expect(entry.sessionId).toBe('fork-session-9');
+    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(row?.external_thread_id).toBe('fork-session-9');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// startTurn — thread fork isolation (BUG 1 + BUG 2 regression tests)
+// ---------------------------------------------------------------------------
+
+/** Build a mock `Query` whose async iterator yields the given SDK messages in
+ *  order, then ends. getContextUsage resolves an empty snapshot (0/0) so the
+ *  result/success handler completes the turn without emitting contextUsage. */
+function createClaudeQueryMock(messages: unknown[]): unknown {
+  return {
+    getContextUsage: vi.fn().mockResolvedValue({
+      totalTokens: 0, maxTokens: 0, rawMaxTokens: 0, percentage: 0,
+      categories: [], gridRows: [], model: '', memoryFiles: [], mcpTools: [],
+    }),
+    interrupt: vi.fn(),
+    setModel: vi.fn(),
+    close: vi.fn(),
+    stopTask: vi.fn(),
+    initializationResult: vi.fn(),
+    [Symbol.asyncIterator]: async function* () {
+      for (const m of messages) yield m;
+    },
+  };
+}
+
+/** A `system/init` SDK message carrying the given Claude session id. */
+function initMsg(claudeSessionId: string): unknown {
+  return { type: 'system', subtype: 'init', session_id: claudeSessionId };
+}
+
+/** A `result/success` SDK message that completes a turn. */
+function resultSuccessMsg(claudeSessionId: string): unknown {
+  return {
+    type: 'result', subtype: 'success',
+    usage: { input_tokens: 10, cache_read_input_tokens: 0, cache_creation_input_tokens: 0, output_tokens: 5 },
+    modelUsage: {}, result: 'done', is_error: false, num_turns: 1,
+    stop_reason: 'end_turn', duration_ms: 1, duration_api_ms: 1, total_cost_usd: 0,
+    permission_denials: [], uuid: 'u1', session_id: claudeSessionId,
+  };
+}
+
+/** Poll the DB until the given turn reaches the expected status. */
+async function waitForTurnStatus(db: Database.Database, turnId: string, status: string, timeoutMs = 2000): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const row = db.prepare('SELECT status FROM turns WHERE id = ?').get(turnId) as { status: string } | undefined;
+    if (row?.status === status) return;
+    await new Promise((r) => setTimeout(r, 10));
+  }
+  throw new Error(`turn ${turnId} did not reach status '${status}' within ${timeoutMs}ms`);
+}
+
+describe('startTurn — thread fork isolation', () => {
+  let db: Database.Database;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    clearAllThreads();
+    captured.length = 0;
+    db = initDb(':memory:');
+    // Main Claude session with a known resume id. Title set so syncThreadTitle
+    // short-circuits (no title-generation query).
+    db.prepare(
+      `INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, external_thread_id, created_at, updated_at)
+       VALUES ('s1', 'Test', 'claude', 'active', 0, 'working', 'main-1', ?, ?)`,
+    ).run(new Date().toISOString(), new Date().toISOString());
+  });
+
+  afterEach(() => {
+    clearAllThreads();
+    db.close();
+  });
+
+  it('main session resumes from its own persisted external_thread_id', async () => {
+    // Seed a MAIN turn (no thread_id).
+    const now = new Date().toISOString();
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, status, created_at, updated_at)
+       VALUES ('t1', 's1', 'hi', 'pending', ?, ?)`,
+    ).run(now, now);
+
+    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('main-1'), resultSuccessMsg('main-1')]) as never);
+
+    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as never;
+    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('t1') as never;
+    await claudeProvider.startTurn(session, turn);
+
+    await waitForTurnStatus(db, 't1', 'completed');
+
+    // The main session's query was started with resume = its persisted external_thread_id.
+    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
+    expect(opts.resume).toBe('main-1');
+  });
+
+  it('thread turn resumes from its OWN fork id and does NOT corrupt the main session (BUG 1 + BUG 2)', async () => {
+    const now = new Date().toISOString();
+    // Anchor turn + a discussion thread forked to 'fork-9'.
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, agent_response, status, created_at, updated_at)
+       VALUES ('t1', 's1', 'hi', 'resp', 'completed', ?, ?)`,
+    ).run(now, now);
+    db.prepare(
+      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, external_thread_id, status, created_at, updated_at)
+       VALUES ('th1', 's1', 'i1', 't1', 0, 4, 'resp', 'fork-9', 'open', ?, ?)`,
+    ).run(now, now);
+    // Thread turn.
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, status, thread_id, created_at, updated_at)
+       VALUES ('tt1', 's1', 'discuss this', 'pending', 'th1', ?, ?)`,
+    ).run(now, now);
+
+    // The forked query emits init with the FORK's session id, then completes.
+    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fork-9'), resultSuccessMsg('fork-9')]) as never);
+
+    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as never;
+    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('tt1') as never;
+    await claudeProvider.startTurn(session, turn);
+
+    await waitForTurnStatus(db, 'tt1', 'completed');
+
+    // BUG 2: the thread resumed its OWN fork ('fork-9'), not the main session.
+    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
+    expect(opts.resume).toBe('fork-9');
+
+    // BUG 1: the main session's external_thread_id was NOT overwritten with the
+    // fork's id (the system/init handler skipped the DB write for thread entries).
+    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(row?.external_thread_id).toBe('main-1');
+  });
+
+  it('thread turn with a FAILED fork starts a fresh isolated session (resume undefined), never the main session (BUG 2)', async () => {
+    const now = new Date().toISOString();
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, agent_response, status, created_at, updated_at)
+       VALUES ('t1', 's1', 'hi', 'resp', 'completed', ?, ?)`,
+    ).run(now, now);
+    // Thread with NO external_thread_id (fork failed / not created).
+    db.prepare(
+      `INSERT INTO discussion_threads (id, session_id, item_id, turn_id, start_offset, end_offset, selected_text, status, created_at, updated_at)
+       VALUES ('th1', 's1', 'i1', 't1', 0, 4, 'resp', 'open', ?, ?)`,
+    ).run(now, now);
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, status, thread_id, created_at, updated_at)
+       VALUES ('tt1', 's1', 'discuss this', 'pending', 'th1', ?, ?)`,
+    ).run(now, now);
+
+    // Fresh session emits its own init id, then completes.
+    vi.mocked(query).mockReturnValue(createClaudeQueryMock([initMsg('fresh-1'), resultSuccessMsg('fresh-1')]) as never);
+
+    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get('s1') as never;
+    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('tt1') as never;
+    await claudeProvider.startTurn(session, turn);
+
+    await waitForTurnStatus(db, 'tt1', 'completed');
+
+    // The thread started a FRESH session: no `resume` option (must NOT fall back
+    // to the main session's 'main-1').
+    const opts = (vi.mocked(query).mock.calls[0][0] as { options: { resume?: string } }).options;
+    expect(opts.resume).toBeUndefined();
+
+    // The main session is untouched.
+    const row = db.prepare('SELECT external_thread_id FROM sessions WHERE id = ?').get('s1') as
+      | { external_thread_id: string | null }
+      | undefined;
+    expect(row?.external_thread_id).toBe('main-1');
+  });
 });

package/agent-pane/backend/src/claude/claude-provider.ts

@@ -159,7 +159,12 @@ async function ensureSessionStarted(
 ): Promise<ClaudeSessionEntry> {
   const db = getDb();
   const key = mapKey ?? session.id;
-  const resumeId = resumeSessionId ?? session.external_thread_id ?? undefined;
+  // Main session (no mapKey) falls back to its persisted external_thread_id so it
+  // resumes the existing conversation. Thread (forked) entries must NOT fall back
+  // to the main session's external_thread_id — that would append the thread's
+  // messages to the MAIN session transcript (resume appends to the same file).
+  // An explicit undefined resume for a thread starts a fresh isolated session.
+  const resumeId = mapKey !== undefined ? resumeSessionId : (resumeSessionId ?? session.external_thread_id ?? undefined);
 
   // Build options — same as the old per-turn options, but applied once per session.
   const options: Options = {
@@ -281,12 +286,14 @@ async function startTurn(session: Session, turn: Turn): Promise<void> {
   if (!entry) {
     try {
       if (turn.thread_id) {
-        // Thread turn — resume from the thread's forked session ID (stored in discussion_threads)
+        // Thread turn — resume from the thread's OWN forked session id. Do NOT
+        // fall back to the main session's external_thread_id: if the fork failed
+        // (thread has no external_thread_id), start a FRESH isolated session
+        // instead, so the thread never appends to the main session transcript.
         const thread = db
           .prepare('SELECT external_thread_id FROM discussion_threads WHERE id = ?')
           .get(turn.thread_id) as { external_thread_id: string | null } | undefined;
-        const resumeId = thread?.external_thread_id ?? session.external_thread_id ?? undefined;
-        entry = await ensureSessionStarted(session, mapKey, resumeId);
+        entry = await ensureSessionStarted(session, mapKey, thread?.external_thread_id ?? undefined);
       } else {
         entry = await ensureSessionStarted(session);
       }
@@ -300,6 +307,11 @@ async function startTurn(session: Session, turn: Turn): Promise<void> {
     }
   }
 
+  // Tag thread entries so the system/init handler can avoid corrupting the
+  // main session's external_thread_id with the fork's session id. Set on every
+  // startTurn (covers both freshly-created and reused sessionMap entries).
+  entry.threadId = turn.thread_id ?? null;
+
   // Complete previous turn if still running (e.g. Monitor was active).
   // All messages between user prompts belong to one AgentPane turn —
   // Monitor-triggered internal turns do NOT create separate AgentPane turns.
@@ -369,7 +381,7 @@ async function startTurn(session: Session, turn: Turn): Promise<void> {
 // ---------------------------------------------------------------------------
 
 /** Handle a single SDK message — dispatch to the correct handler. */
-async function handleMessage(
+export async function handleMessage(
   message: SDKMessage,
   sessionId: string,
   turnId: string,
@@ -381,12 +393,21 @@ async function handleMessage(
       if ('subtype' in message) {
         const sub = (message as { subtype: string }).subtype;
         if (sub === 'init') {
-          // Save Claude session ID for resume (idempotent — Monitor triggers multiple inits)
+          // Always capture the Claude session id (needed for Monitor output-path
+          // construction). Idempotent — Monitor triggers multiple inits.
           entry.sessionId = (message as { session_id: string }).session_id;
-          const now = new Date().toISOString();
-          db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
-            (message as { session_id: string }).session_id, now, sessionId,
-          );
+          // Only persist the resume id for the MAIN session. For thread (forked)
+          // entries, the fork's session id already lives in
+          // discussion_threads.external_thread_id; writing it here would corrupt
+          // the MAIN session's external_thread_id, causing the main session to
+          // resume the fork after a restart/rewind and "remember" the thread's
+          // discussion.
+          if (!entry.threadId) {
+            const now = new Date().toISOString();
+            db.prepare('UPDATE sessions SET external_thread_id = ?, updated_at = ? WHERE id = ?').run(
+              (message as { session_id: string }).session_id, now, sessionId,
+            );
+          }
         } else if (sub === 'compact_boundary') {
           handleCompactBoundary(message as SDKMessage & { type: 'system'; subtype: 'compact_boundary' }, sessionId, turnId, db);
         } else if (sub === 'task_started') {
@@ -420,7 +441,7 @@ async function handleMessage(
     }
 
     case 'result': {
-      handleResultMessage(message, sessionId, turnId, db);
+      handleResultMessage(message, sessionId, turnId, entry, db);
       break;
     }
 
@@ -861,18 +882,17 @@ function handleBackgroundTasksChanged(
   };
   broadcast('background_tasks', { sessionId, tasks: m.tasks ?? [] });
 }
-
 /** Handle SDKResultMessage — accumulate usage across multi-result turns (Monitor).
  *  Does NOT complete the turn on intermediate results — the turn completes when
  *  the next user message is pushed (in startTurn) or when the PromptQueue is
  *  closed (in the message loop's generator-end block). Only error results abort early. */
-function handleResultMessage(
+export async function handleResultMessage(
   message: SDKMessage & { type: 'result' },
   sessionId: string,
   turnId: string,
+  entry: ClaudeSessionEntry,
   db: Database.Database,
-): void {
-  // Subagent result — skip entirely. Prevents subagent token/context data from
+): Promise<void> {  // Subagent result — skip entirely. Prevents subagent token/context data from
   // overwriting the main session's token_usage and contextUsage.
   // SDKResultSuccess doesn't declare parent_tool_use_id in its type, but the SDK
   // may set it at runtime (same pattern as handleAssistantMessage/handleUserMessage).
@@ -892,45 +912,28 @@ function handleResultMessage(
     );
     broadcast('turn:tokenUsage', { sessionId, turnId, usage });
 
-    // Extract context window usage from modelUsage (cumulative, includes contextWindow per model).
-    // Total context ≈ input_tokens + cache_read + cache_creation for this turn.
-    const result = message as SDKMessage & { type: 'result'; subtype: 'success' };
-    const modelUsage = result.modelUsage;
-
-    // Look up the main agent's model in modelUsage to get the correct contextWindow.
-    // modelUsage includes ALL models (main + subagents + sidechains), so taking
-    // Object.values()[0] may pick a subagent model with a different contextWindow.
-    const session = db.prepare('SELECT model FROM sessions WHERE id = ?').get(sessionId) as
-      | { model: string | null }
-      | undefined;
-    const sessionModel = session?.model ?? null;
-
-    let modelEntry = undefined;
-    if (modelUsage) {
-      if (sessionModel && modelUsage[sessionModel]) {
-        modelEntry = modelUsage[sessionModel];
-      } else {
-        // Fallback: find an entry whose canonicalModel matches, else first entry
-        modelEntry = Object.values(modelUsage).find(
-          (e) => sessionModel && e.canonicalModel === sessionModel,
-        ) ?? Object.values(modelUsage)[0];
-      }
-    }
-
-    if (modelEntry && modelEntry.contextWindow > 0) {
-      const totalTokens =
-        result.usage.input_tokens +
-        (result.usage.cache_read_input_tokens ?? 0) +
-        (result.usage.cache_creation_input_tokens ?? 0);
-
-      if (totalTokens > 0) {
+    // Context-window usage: use the SDK's own /context computation (Query.getContextUsage),
+    // NOT the accumulated result.usage input/cache sum. The hand formula double-counts /
+    // accumulates in streaming-input mode (e.g. shows 800K while /context shows the real
+    // 130K). getContextUsage returns the same structured data as the /context command —
+    // the authoritative current in-window fill, computed locally by the CLI.
+    try {
+      const ctx = await entry.query.getContextUsage();
+      if (ctx.totalTokens > 0 && ctx.maxTokens > 0) {
         const contextUsage: ContextUsage = {
-          totalTokens,
-          contextWindow: modelEntry.contextWindow,
-          percentage: Math.round((totalTokens / modelEntry.contextWindow) * 100),
+          totalTokens: ctx.totalTokens,
+          contextWindow: ctx.maxTokens,
+          percentage: Math.round(ctx.percentage),
         };
         broadcast('turn:contextUsage', { sessionId, ...contextUsage });
+        // Persist so the status-bar counter survives page reload.
+        const cuNow = new Date().toISOString();
+        db.prepare('UPDATE sessions SET context_usage = ?, updated_at = ? WHERE id = ?').run(
+          JSON.stringify(contextUsage), cuNow, sessionId,
+        );
       }
+    } catch {
+      // getContextUsage unavailable (older CLI) or failed — leave contextUsage unchanged.
     }
 
     completeTurn(db, sessionId, turnId, usage);

package/agent-pane/backend/src/db/index.ts

@@ -175,6 +175,12 @@ function createTables(database: Database.Database): void {
     database.exec('ALTER TABLE sessions ADD COLUMN pre_rewind_thread_id TEXT');
   }
 
+  // Migration: add 'context_usage' column — persisted last-known context-window usage
+  // (JSON of ContextUsage) so the status-bar counter survives page reload.
+  if (!sessColumns.some((c) => c.name === 'context_usage')) {
+    database.exec('ALTER TABLE sessions ADD COLUMN context_usage TEXT');
+  }
+
   // Migration: add 'thread_id' column to turns table (discussion threads feature)
   const turnColumns = database.prepare('PRAGMA table_info(turns)').all() as { name: string }[];
   if (!turnColumns.some((c) => c.name === 'thread_id')) {

package/agent-pane/backend/src/index.ts

@@ -23,8 +23,11 @@ async function main(): Promise<void> {
   // Initialize database
   initDb('data.db');
 
-  // Create Fastify server
-  const fastify = Fastify({ logger: true });
+  // Create Fastify server.
+  // bodyLimit: default is 1 MiB, which rejects image attachments (sent as base64
+  // in JSON) larger than ~780 KB with 413 Payload Too Large. 50 MB covers the
+  // largest payloads Claude accepts (Anthropic: ~32 MB max request, 5 MB/image).
+  const fastify = Fastify({ logger: true, bodyLimit: 50 * 1024 * 1024 });
 
   // Register CORS (allow Vite dev server)
   await fastify.register(cors, { origin: true });