repoburg 1.3.199 → 1.3.202

package/agent-pane/backend/src/repoburg/turn-projector.test.ts

@@ -0,0 +1,621 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Capture broadcasts.
+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 { TurnProjector, RESULT_TIMEOUT_MS, MAX_RESULT_EXTENSIONS } from './turn-projector.ts';
+import type { AgentRuntimeActionInfo, AgentRuntimeMessage } from './agent-runtime-client.ts';
+import { initDb } from '../db/index.ts';
+import type Database from 'better-sqlite3';
+import type { RepoburgRuntimeClient } from './repoburg-client.ts';
+
+const SESSION_ID = 's1';
+const TURN_ID = 't1';
+const RUNTIME_SESSION_ID = 'rs-1';
+
+/** Standard action info block for tool_result messages. */
+function actionInfo(overrides: Partial<AgentRuntimeActionInfo> = {}): AgentRuntimeActionInfo {
+  return {
+    id: 'a1',
+    action_type: 'create_file',
+    file_path: 'src/a.ts',
+    command_string: null,
+    status: 'CONFIRMED_KEPT',
+    server_name: null,
+    tool_name: null,
+    arguments: null,
+    plain: null,
+    selections: null,
+    order_of_execution: 0,
+    ...overrides,
+  };
+}
+
+describe('TurnProjector', () => {
+  let db: Database.Database;
+  let projector: TurnProjector | null = null;
+  const client = {
+    getSessionInputs: vi.fn(),
+    getSession: vi.fn(),
+  } as unknown as RepoburgRuntimeClient;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    captured.length = 0;
+    db = initDb(':memory:');
+    const now = new Date().toISOString();
+    db.prepare(
+      `INSERT INTO sessions (id, title, runtime_type, status, is_running, lifecycle, created_at, updated_at)
+       VALUES (?, NULL, 'repoburg', 'running', 1, 'working', ?, ?)`,
+    ).run(SESSION_ID, now, now);
+    db.prepare(
+      `INSERT INTO turns (id, session_id, user_prompt, status, created_at, updated_at)
+       VALUES (?, ?, 'hello', 'running', ?, ?)`,
+    ).run(TURN_ID, SESSION_ID, now, now);
+  });
+
+  afterEach(() => {
+    projector?.close();
+    projector = null;
+    db.close();
+    vi.useRealTimers();
+  });
+
+  function makeProjector(): TurnProjector {
+    projector = new TurnProjector({
+      agentPaneSessionId: SESSION_ID,
+      turnId: TURN_ID,
+      repoburgSessionId: RUNTIME_SESSION_ID,
+      client,
+    });
+    return projector;
+  }
+
+  function items(): Array<{ external_item_id: string; type: string; status: string; data: string }> {
+    return db
+      .prepare('SELECT external_item_id, type, status, data FROM items WHERE turn_id = ? ORDER BY rowid')
+      .all(TURN_ID) as never;
+  }
+
+  function turnRow(): { status: string; agent_response: string | null; token_usage: string | null; error: string | null } {
+    return db.prepare('SELECT status, agent_response, token_usage, error FROM turns WHERE id = ?').get(TURN_ID) as never;
+  }
+
+  describe('stream_event + assistant', () => {
+    it('starts items on first delta and streams further deltas', () => {
+      const p = makeProjector();
+
+      p.handle({
+        type: 'stream_event',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        delta: { type: 'text', text: 'Hel' },
+      });
+      p.handle({
+        type: 'stream_event',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        delta: { type: 'text', text: 'lo' },
+      });
+
+      const rows = items();
+      expect(rows).toHaveLength(1);
+      expect(rows[0].type).toBe('agent_message');
+      expect(rows[0].status).toBe('in_progress');
+      expect(JSON.parse(rows[0].data)).toEqual({ text: 'Hel' }); // item data from FIRST insert
+
+      const delta = captured.find((b) => b.event === 'item:delta');
+      expect(delta).toBeDefined();
+      expect(delta!.data).toMatchObject({ turnId: TURN_ID, itemId: 'in-1-text', delta: 'lo' });
+    });
+it('records runtime input ids into turns.runtime_input_ids (rewind anchor mapping)', () => {
+      const p = makeProjector();
+
+      // Round 1
+      p.handle({
+        type: 'assistant',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [{ type: 'text', text: 'Round one' }],
+      });
+      // Round 2 (multi-round turn)
+      p.handle({
+        type: 'assistant',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-2',
+        content: [{ type: 'text', text: 'Round two' }],
+      });
+      // Replay of an existing round must NOT duplicate the id
+      p.handle({
+        type: 'stream_event',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-2',
+        delta: { type: 'text', text: ' again' },
+      });
+
+      const row = db
+        .prepare('SELECT runtime_input_ids FROM turns WHERE id = ?')
+        .get(TURN_ID) as { runtime_input_ids: string | null };
+      expect(JSON.parse(row.runtime_input_ids!)).toEqual(['in-1', 'in-2']);
+    });
+
+    it('completes streamed items when the assistant message arrives', () => {
+      const p = makeProjector();
+      p.handle({
+        type: 'stream_event',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        delta: { type: 'text', text: 'Hel' },
+      });
+      p.handle({
+        type: 'assistant',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [
+          { type: 'thinking', thinking: 'hmm' },
+          { type: 'text', text: 'Hello world' },
+        ],
+      });
+
+      const rows = items();
+      expect(rows.map((r) => r.type)).toEqual(['agent_message', 'reasoning']);
+      expect(rows.every((r) => r.status === 'completed')).toBe(true);
+      expect(JSON.parse(rows[0].data)).toEqual({ text: 'Hello world' });
+      expect(JSON.parse(rows[1].data)).toEqual({ text: 'hmm' });
+    });
+
+    it('creates completed items from assistant alone (deltas off/missed)', () => {
+      const p = makeProjector();
+      p.handle({
+        type: 'assistant',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [{ type: 'text', text: 'Hello' }],
+      });
+
+      const rows = items();
+      expect(rows).toHaveLength(1);
+      expect(rows[0].status).toBe('completed');
+      expect(JSON.parse(rows[0].data)).toEqual({ text: 'Hello' });
+    });
+  });
+
+  describe('user tool_result', () => {
+    it('maps actions to items and skips final/html_final (part of the response)', () => {
+      const p = makeProjector();
+      p.handle({
+        type: 'user',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'a1',
+            content: 'created',
+            is_error: false,
+            action: actionInfo({ id: 'a1', action_type: 'create_file' }),
+          },
+          {
+            type: 'tool_result',
+            tool_use_id: 'a2',
+            content: 'ls output',
+            is_error: false,
+            action: actionInfo({ id: 'a2', action_type: 'run_command', file_path: null, command_string: 'ls' }),
+          },
+          {
+            type: 'tool_result',
+            tool_use_id: 'a3',
+            content: 'final text',
+            is_error: false,
+            action: actionInfo({ id: 'a3', action_type: 'final', plain: 'Final text' }),
+          },
+        ],
+      });
+
+      const rows = items();
+      expect(rows.map((r) => r.external_item_id)).toEqual(['in-1-action-a1', 'in-1-action-a2']);
+      expect(rows[0].type).toBe('file_change');
+      expect(rows[1].type).toBe('command_execution');
+      expect(JSON.parse(rows[1].data).aggregated_output).toBe('ls output');
+    });
+
+    it('maps failed actions to failed items with the error text', () => {
+      const p = makeProjector();
+      p.handle({
+        type: 'user',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'a1',
+            content: 'command crashed',
+            is_error: true,
+            action: actionInfo({
+              id: 'a1',
+              action_type: 'run_command',
+              file_path: null,
+              command_string: 'boom',
+              status: 'EXECUTION_FAILED',
+            }),
+          },
+        ],
+      });
+
+      const rows = items();
+      expect(rows).toHaveLength(1);
+      expect(rows[0].status).toBe('failed');
+      expect(JSON.parse(rows[0].data).status).toBe('failed');
+    });
+
+    it('is idempotent — replayed messages do not duplicate items', () => {
+      const p = makeProjector();
+      const assistant: AgentRuntimeMessage = {
+        type: 'assistant',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [{ type: 'text', text: 'Hello' }],
+      };
+      const user: AgentRuntimeMessage = {
+        type: 'user',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'a1',
+            content: 'created',
+            is_error: false,
+            action: actionInfo(),
+          },
+        ],
+      };
+
+      p.handle(assistant);
+      p.handle(user);
+      p.handle(assistant); // replay (reconnect)
+      p.handle(user);
+
+      expect(items().map((r) => r.external_item_id).sort()).toEqual(['in-1-action-a1', 'in-1-text']);
+    });
+  });
+
+  describe('result', () => {
+    it('success completes the turn with result text, usage, and title sync', async () => {
+      (client.getSession as ReturnType<typeof vi.fn>).mockResolvedValue({
+        id: RUNTIME_SESSION_ID,
+        session_title: 'Synced Title',
+        is_running: false,
+      });
+      const p = makeProjector();
+
+      p.handle({
+        type: 'assistant',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [{ type: 'text', text: 'working' }],
+      });
+      p.handle({
+        type: 'result',
+        subtype: 'success',
+        sessionId: RUNTIME_SESSION_ID,
+        is_error: false,
+        result: 'All done',
+        usage: { input_tokens: 10, output_tokens: 5, cache_read_input_tokens: 2, cache_creation_input_tokens: 0 },
+        num_rounds: 2,
+      });
+
+      const row = turnRow();
+      expect(row.status).toBe('completed');
+      expect(row.agent_response).toBe('All done');
+      expect(JSON.parse(row.token_usage!)).toMatchObject({
+        input_tokens: 10,
+        output_tokens: 5,
+        cached_input_tokens: 2,
+      });
+      expect(captured.find((b) => b.event === 'turn:completed')).toBeDefined();
+      // The completion broadcast carries the final text — the FE renders it
+      // for final-action turns that have no agent_message item.
+      const completed = captured.find((b) => b.event === 'turn:completed');
+      expect(completed!.data).toMatchObject({ response: 'All done' });
+
+      // Session marked not-running with unreviewed actions.
+      const session = db.prepare('SELECT is_running, status, has_unreviewed FROM sessions WHERE id = ?').get(SESSION_ID) as never;
+      expect(session).toMatchObject({ is_running: 0, status: 'active', has_unreviewed: 1 });
+
+      // Title sync (async, fire-and-forget).
+      await vi.waitFor(() => {
+        const s = db.prepare('SELECT title FROM sessions WHERE id = ?').get(SESSION_ID) as { title: string | null };
+        expect(s.title).toBe('Synced Title');
+      });
+      expect(captured.find((b) => b.event === 'session:title')).toBeDefined();
+
+      // Projector done — later messages ignored.
+      p.handle({
+        type: 'result',
+        subtype: 'success',
+        sessionId: RUNTIME_SESSION_ID,
+        is_error: false,
+        result: 'late',
+        num_rounds: 0,
+      } as never);
+      expect(turnRow().agent_response).toBe('All done');
+    });
+
+    it('success falls back to the last round text when result text is empty', () => {
+      const p = makeProjector();
+      p.handle({
+        type: 'assistant',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [{ type: 'text', text: 'Fallback text' }],
+      });
+      p.handle({
+        type: 'result',
+        subtype: 'success',
+        sessionId: RUNTIME_SESSION_ID,
+        is_error: false,
+        result: '',
+        num_rounds: 1,
+      });
+
+      expect(turnRow().agent_response).toBe('Fallback text');
+    });
+
+    it('error fails the turn and closes open items as failed', () => {
+      const p = makeProjector();
+      p.handle({
+        type: 'stream_event',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        delta: { type: 'text', text: 'partial' },
+      });
+      p.handle({
+        type: 'result',
+        subtype: 'error_during_execution',
+        sessionId: RUNTIME_SESSION_ID,
+        is_error: true,
+        result: '',
+        num_rounds: 1,
+        errors: ['boom', 'bang'],
+      });
+
+      const row = turnRow();
+      expect(row.status).toBe('failed');
+      expect(row.error).toBe('boom; bang');
+      expect(items()[0].status).toBe('failed');
+      expect(captured.find((b) => b.event === 'turn:failed')).toBeDefined();
+    });
+
+    it('aborted aborts the turn and closes open items as completed', () => {
+      const p = makeProjector();
+      p.handle({
+        type: 'stream_event',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        delta: { type: 'text', text: 'partial' },
+      });
+      p.handle({
+        type: 'result',
+        subtype: 'aborted',
+        sessionId: RUNTIME_SESSION_ID,
+        is_error: true,
+        result: '',
+        num_rounds: 0,
+      });
+
+      expect(turnRow().status).toBe('aborted');
+      expect(items()[0].status).toBe('completed');
+      expect(captured.find((b) => b.event === 'turn:cancelled')).toBeDefined();
+    });
+  });
+
+  describe('watch-dog + snapshot reconcile', () => {
+    it('completes the turn from the snapshot when the result never arrives', async () => {
+      vi.useFakeTimers();
+      (client.getSessionInputs as ReturnType<typeof vi.fn>).mockResolvedValue([
+        {
+          id: 'in-1',
+          role: 'model',
+          raw_llm_response: 'Snapshot reply',
+          thoughts: null,
+          input_token_count: 12,
+          output_token_count: 6,
+          cached_token_count: 3,
+          aiActions: [
+            {
+              id: 'a1',
+              action_type: 'create_file',
+              file_path: 'src/x.ts',
+              status: 'CONFIRMED_KEPT',
+              order_of_execution: 0,
+              executionLogs: [{ output: 'created', error_message: null }],
+            },
+          ],
+        },
+      ]);
+      (client.getSession as ReturnType<typeof vi.fn>).mockResolvedValue({
+        id: RUNTIME_SESSION_ID,
+        session_title: null,
+        is_running: false,
+      });
+
+      const p = makeProjector();
+      p.handle({
+        type: 'assistant',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [{ type: 'text', text: 'Snapshot reply' }],
+      });
+
+      await vi.advanceTimersByTimeAsync(RESULT_TIMEOUT_MS + 1000);
+
+      // Snapshot projected (action item) and turn completed.
+      const ids = items().map((r) => r.external_item_id);
+      expect(ids).toContain('in-1-action-a1');
+      const row = turnRow();
+      expect(row.status).toBe('completed');
+      expect(row.agent_response).toBe('Snapshot reply');
+      expect(JSON.parse(row.token_usage!)).toMatchObject({ input_tokens: 12, output_tokens: 6, cached_input_tokens: 3 });
+      expect(client.getSessionInputs).toHaveBeenCalledWith(RUNTIME_SESSION_ID);
+    });
+
+    it('re-arms while the runtime session is still running, then fails after max extensions', async () => {
+      vi.useFakeTimers();
+      (client.getSessionInputs as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+      (client.getSession as ReturnType<typeof vi.fn>).mockResolvedValue({
+        id: RUNTIME_SESSION_ID,
+        session_title: null,
+        is_running: true,
+      });
+
+      makeProjector();
+
+      const firings = MAX_RESULT_EXTENSIONS + 1;
+      await vi.advanceTimersByTimeAsync(RESULT_TIMEOUT_MS * firings + 1000 * firings);
+
+      const row = turnRow();
+      expect(row.status).toBe('failed');
+      expect(row.error).toMatch(/still running/);
+    });
+
+    describe('subagent lifecycle → background_task', () => {
+    /** One registered sub-agent event message. */
+    function subagent(event: 'started' | 'progress' | 'completed' | 'failed', extra: Record<string, unknown> = {}): AgentRuntimeMessage {
+      return {
+        type: 'subagent',
+        sessionId: RUNTIME_SESSION_ID,
+        event,
+        task_id: 'child-1',
+        agent_name: 'explore-codebase',
+        description: 'Find auth files',
+        input_id: 'in-1',
+        action_id: 'act-1',
+        ...extra,
+      };
+    }
+
+    it('started/progress/completed converge on ONE background_task item', () => {
+      const p = makeProjector();
+
+      p.handle(subagent('started'));
+      let rows = items();
+      expect(rows).toHaveLength(1);
+      expect(rows[0]).toMatchObject({
+        external_item_id: 'in-1-action-act-1',
+        type: 'background_task',
+        status: 'in_progress',
+      });
+      expect(JSON.parse(rows[0].data)).toMatchObject({
+        task_id: 'child-1',
+        description: 'Find auth files',
+        task_type: 'subagent',
+        subagent_type: 'explore-codebase',
+        status: 'running',
+      });
+
+      p.handle(subagent('progress', { description: 'create_file: src/auth.ts', last_tool_name: 'create_file', token_count: 120 }));
+      rows = items();
+      expect(rows).toHaveLength(1); // SAME item — no duplicates
+      expect(JSON.parse(rows[0].data)).toMatchObject({
+        description: 'create_file: src/auth.ts',
+        last_tool_name: 'create_file',
+        token_count: 120,
+        status: 'running',
+      });
+      const updated = captured.filter((b) => b.event === 'item:updated');
+      expect(updated).toHaveLength(1);
+
+      p.handle(subagent('completed', { summary: 'auth files found', usage: { input_tokens: 100, output_tokens: 20, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } }));
+      rows = items();
+      expect(rows).toHaveLength(1);
+      expect(rows[0].status).toBe('completed');
+      expect(JSON.parse(rows[0].data)).toMatchObject({
+        status: 'completed',
+        summary: 'auth files found',
+      });
+    });
+
+    it('failed settlement marks the card failed', () => {
+      const p = makeProjector();
+
+      p.handle(subagent('started'));
+      p.handle(subagent('failed', { summary: 'boom' }));
+
+      const rows = items();
+      expect(rows).toHaveLength(1);
+      expect(rows[0].status).toBe('failed');
+      expect(JSON.parse(rows[0].data)).toMatchObject({ status: 'failed', summary: 'boom' });
+    });
+
+    it('invoke_subagent tool_result with the same action id does NOT duplicate the live card', () => {
+      const p = makeProjector();
+
+      p.handle(subagent('started'));
+      p.handle({
+        type: 'user',
+        sessionId: RUNTIME_SESSION_ID,
+        inputId: 'in-1',
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'act-1',
+            content: 'child output',
+            is_error: false,
+            action: actionInfo({
+              id: 'act-1',
+              action_type: 'invoke_subagent',
+              arguments: JSON.stringify({ agent_name: 'explore-codebase', prompt: 'Find auth files' }),
+              file_path: null,
+            }),
+          },
+        ],
+      });
+
+      const rows = items();
+      expect(rows).toHaveLength(1);
+      expect(rows[0].external_item_id).toBe('in-1-action-act-1');
+      expect(rows[0].type).toBe('background_task');
+    });
+
+    it('a completed card from subagent events survives a later completed event idempotently', () => {
+      const p = makeProjector();
+
+      p.handle(subagent('started'));
+      p.handle(subagent('completed', { summary: 'done' }));
+      p.handle(subagent('completed', { summary: 'done' })); // replay
+
+      const rows = items();
+      expect(rows).toHaveLength(1);
+      expect(rows[0].status).toBe('completed');
+    });
+  });
+it('a live result cancels the watchdog', async () => {
+      vi.useFakeTimers();
+      const p = makeProjector();
+      p.handle({
+        type: 'result',
+        subtype: 'success',
+        sessionId: RUNTIME_SESSION_ID,
+        is_error: false,
+        result: 'done',
+        num_rounds: 1,
+      });
+      expect(turnRow().status).toBe('completed');
+
+      (client.getSessionInputs as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+      await vi.advanceTimersByTimeAsync(RESULT_TIMEOUT_MS * 5);
+      expect(client.getSessionInputs).not.toHaveBeenCalled();
+      expect(p.isDone).toBe(true);
+    });
+  });
+});