repoburg 1.3.201 → 1.3.202

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

@@ -66,6 +66,7 @@ function makeMockClient(): { client: RepoburgRuntimeClient } {
     createInput: vi.fn(),
     getInputWithActions: vi.fn(),
     getSessionInputs: vi.fn(),
+    deleteInputsUntilHere: vi.fn().mockResolvedValue(undefined),
     cancel: vi.fn().mockResolvedValue({ success: true, cancelled: true }),
     getModels: vi.fn(),
   } as unknown as RepoburgRuntimeClient;
@@ -136,6 +137,58 @@ describe('repoburgProvider', () => {
     expect(repoburgProvider.getModels).toBeTypeOf('function');
     expect(repoburgProvider.shutdown).toBeTypeOf('function');
   });
+it('implements all RuntimeProvider methods', () => {
+    expect(repoburgProvider.startTurn).toBeTypeOf('function');
+    expect(repoburgProvider.interruptTurn).toBeTypeOf('function');
+    expect(repoburgProvider.clearThread).toBeTypeOf('function');
+    expect(repoburgProvider.clearAllThreads).toBeTypeOf('function');
+    expect(repoburgProvider.getModels).toBeTypeOf('function');
+    expect(repoburgProvider.rewindRuntime).toBeTypeOf('function');
+    expect(repoburgProvider.shutdown).toBeTypeOf('function');
+  });
+
+  it('rewindRuntime truncates via until-here with the LAST runtime input id', async () => {
+    db.prepare('UPDATE sessions SET external_thread_id = ? WHERE id = ?').run('rs-1', 's1');
+    const { session } = seedTurn('t1');
+    db.prepare('UPDATE turns SET runtime_input_ids = ? WHERE id = ?').run(
+      JSON.stringify(['in-1', 'in-2', 'in-3']),
+      't1',
+    );
+    // Re-load the turn row AFTER the update (seedTurn fetched a stale row).
+    const turn = db.prepare('SELECT * FROM turns WHERE id = ?').get('t1') as Turn;
+
+    await repoburgProvider.rewindRuntime!(session, turn);
+
+    expect(mock.client.deleteInputsUntilHere).toHaveBeenCalledWith('rs-1', 'in-3');
+  });
+
+  it('rewindRuntime throws when the turn has no runtime input ids', async () => {
+    db.prepare('UPDATE sessions SET external_thread_id = ? WHERE id = ?').run('rs-1', 's1');
+    const { session, turn } = seedTurn('t1');
+
+    await expect(repoburgProvider.rewindRuntime!(session, turn)).rejects.toThrow(
+      'no runtime input ids',
+    );
+    expect(mock.client.deleteInputsUntilHere).not.toHaveBeenCalled();
+  });
+
+  it('rewindRuntime is a no-op when the session has no runtime thread', async () => {
+    const { session, turn } = seedTurn('t1');
+
+    await repoburgProvider.rewindRuntime!(session, turn);
+
+    expect(mock.client.deleteInputsUntilHere).not.toHaveBeenCalled();
+  });
+
+  it('rewindRuntime accepts the typed Turn array form of runtime_input_ids', async () => {
+    db.prepare('UPDATE sessions SET external_thread_id = ? WHERE id = ?').run('rs-1', 's1');
+    const { session, turn } = seedTurn('t1');
+    const typedTurn = { ...turn, runtime_input_ids: ['in-a', 'in-b'] } as Turn;
+
+    await repoburgProvider.rewindRuntime!(session, typedTurn);
+
+    expect(mock.client.deleteInputsUntilHere).toHaveBeenCalledWith('rs-1', 'in-b');
+  });
 
   describe('mapReasoningEffort', () => {
     it('passes valid Ollama levels through and clamps xhigh to high', () => {
@@ -442,6 +495,7 @@ describe('repoburgProvider', () => {
             tool_name: null,
             arguments: null,
             plain: null,
+            selections: null,
             order_of_execution: 0,
           },
         },
@@ -460,6 +514,7 @@ describe('repoburgProvider', () => {
             tool_name: null,
             arguments: null,
             plain: null,
+            selections: null,
             order_of_execution: 1,
           },
         },
@@ -606,6 +661,7 @@ describe('repoburgProvider', () => {
             tool_name: null,
             arguments: null,
             plain: null,
+            selections: null,
             order_of_execution: 0,
           },
         },
@@ -641,6 +697,7 @@ describe('repoburgProvider', () => {
             tool_name: null,
             arguments: null,
             plain: null,
+            selections: null,
             order_of_execution: 0,
           },
         },

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

@@ -262,6 +262,16 @@ export async function startTurn(session: Session, turn: Turn): Promise<void> {
     return;
   }
 
+  // Pinned-session cross-check (belt and braces): a daemon reshuffle may
+  // resolve a different URL than the one pinned in the session entry. The
+  // pinned entry wins until the session ends (deliberate) — log the mismatch.
+  const pinned = sessionMap.get(session.id);
+  if (pinned && pinned.baseUrl !== baseUrl) {
+    console.warn(
+      `[repoburg] resolved backend ${baseUrl} differs from pinned ${pinned.baseUrl} for session ${session.id} — keeping the pinned entry.`,
+    );
+  }
+
   // Phase 1: ensure the runtime session exists.
   let entry: SessionEntry;
   try {
@@ -372,6 +382,44 @@ export function clearThread(sessionId: string): void {
   sessionMap.delete(sessionId);
 }
 
+/** Parse a turn row's runtime_input_ids (JSON string in DB, array in typed Turn). */
+function parseRuntimeInputIds(turn: Turn): string[] {
+  const raw = (turn as Turn & { runtime_input_ids?: string | string[] | null }).runtime_input_ids;
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw === 'string' && raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed as string[];
+    } catch {
+      // Corrupt JSON — no anchor.
+    }
+  }
+  return [];
+}
+
+/** Truncate the runtime session IN PLACE (platform-parity rewind): hard-delete
+ *  every runtime input after the target turn's LAST runtime input via the
+ *  until-here endpoint. Throws on failure — the caller skips the local rewind.
+ *  forkSession is intentionally NOT implemented for repoburg (a hard-deleted
+ *  session cannot be forked; truncation is the rewind primitive). */
+export async function rewindRuntime(session: Session, targetTurn: Turn): Promise<void> {
+  if (!session.external_thread_id) return; // no runtime session yet — nothing to truncate
+  const anchor = parseRuntimeInputIds(targetTurn).pop();
+  if (!anchor) {
+    throw new Error(
+      'Cannot truncate runtime history — the target turn has no runtime input ids (turn predates rewind support or never ran on repoburg).',
+    );
+  }
+  const entry = sessionMap.get(session.id);
+  let client = entry?.client ?? null;
+  if (!client) {
+    const resolved = await resolveBackendUrl(session.cwd ?? process.cwd());
+    if (!resolved) throw new Error('No repoburg backend resolved.');
+    client = new RepoburgHttpClient(resolved.baseUrl);
+  }
+  await client.deleteInputsUntilHere(session.external_thread_id, anchor);
+}
+
 /** Clear all session state. Used in test cleanup. */
 export function clearAllThreads(): void {
   for (const entry of sessionMap.values()) {
@@ -418,5 +466,6 @@ export const repoburgProvider: RuntimeProvider = {
   clearThread,
   clearAllThreads,
   getModels,
+  rewindRuntime,
   shutdown,
 };

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

@@ -34,6 +34,7 @@ function actionInfo(overrides: Partial<AgentRuntimeActionInfo> = {}): AgentRunti
     tool_name: null,
     arguments: null,
     plain: null,
+    selections: null,
     order_of_execution: 0,
     ...overrides,
   };
@@ -116,6 +117,36 @@ describe('TurnProjector', () => {
       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();
@@ -292,6 +323,10 @@ describe('TurnProjector', () => {
         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;
@@ -453,7 +488,118 @@ describe('TurnProjector', () => {
       expect(row.error).toMatch(/still running/);
     });
 
-    it('a live result cancels the watchdog', async () => {
+    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({

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

@@ -26,12 +26,14 @@ import {
   mapActionToItem,
   mapUsage,
   setSessionStatus,
+  updateItem,
 } from './action-mapping.ts';
 import type {
   AgentRuntimeMessage,
   AssistantMessage,
   ResultMessage,
   StreamEventMessage,
+  SubagentMessage,
   UserMessage,
 } from './agent-runtime-client.ts';
 
@@ -89,6 +91,9 @@ export class TurnProjector {
       case 'user':
         this.handleUser(message);
         break;
+      case 'subagent':
+        this.handleSubagent(message);
+        break;
       case 'result':
         this.handleResult(message);
         break;
@@ -124,10 +129,36 @@ export class TurnProjector {
         finalPlain: null,
       };
       this.rounds.set(inputId, info);
+      this.recordRuntimeInput(inputId);
     }
     return info;
   }
 
+  /** Append a runtime input id to the turn row's runtime_input_ids column —
+   *  the rewind anchor mapping (anchor = LAST id of the target turn). */
+  private recordRuntimeInput(inputId: string): void {
+    try {
+      const db = getDb();
+      const row = db.prepare('SELECT runtime_input_ids FROM turns WHERE id = ?').get(this.deps.turnId) as
+        | { runtime_input_ids: string | null }
+        | undefined;
+      if (!row) return; // turn row gone (deleted session) — skip silently
+      let ids: string[] = [];
+      if (row.runtime_input_ids) {
+        const parsed = JSON.parse(row.runtime_input_ids);
+        if (Array.isArray(parsed)) ids = parsed;
+      }
+      if (ids.includes(inputId)) return;
+      ids.push(inputId);
+      db.prepare('UPDATE turns SET runtime_input_ids = ? WHERE id = ?').run(
+        JSON.stringify(ids),
+        this.deps.turnId,
+      );
+    } catch {
+      // Best-effort recording — rewind only loses anchor precision.
+    }
+  }
+
   private handleStreamEvent(msg: StreamEventMessage): void {
     const db = getDb();
     const info = this.round(msg.inputId);
@@ -271,7 +302,72 @@ export class TurnProjector {
     this.touch();
   }
 
-  private handleResult(msg: ResultMessage): void {
+  /** Sub-agent lifecycle → background_task item (Claude data shape),
+   *  idempotent upsert keyed `<inputId>-action-<actionId>` — the same
+   *  external id the invoke_subagent tool_result/reconcile uses, so all
+   *  paths converge on ONE card. */
+  private handleSubagent(msg: SubagentMessage): void {
+    const db = getDb();
+    const externalId = `${msg.input_id}-action-${msg.action_id}`;
+    const terminal = msg.event === 'completed' || msg.event === 'failed';
+    const itemStatus: Item['status'] = terminal
+      ? msg.event === 'completed'
+        ? 'completed'
+        : 'failed'
+      : 'in_progress';
+
+    const row = db
+      .prepare('SELECT * FROM items WHERE turn_id = ? AND external_item_id = ?')
+      .get(this.deps.turnId, externalId) as
+      | (Omit<Item, 'data'> & { data: string | null })
+      | undefined;
+
+    if (row) {
+      const prev = row.data ? (JSON.parse(row.data) as Record<string, unknown>) : {};
+      const item: Item = { ...row, data: prev } as unknown as Item;
+      updateItem(
+        db,
+        this.deps.agentPaneSessionId,
+        this.deps.turnId,
+        item,
+        {
+          ...prev,
+          description: msg.description,
+          subagent_type: msg.agent_name,
+          status: terminal ? msg.event : 'running',
+          last_tool_name: msg.last_tool_name ?? prev.last_tool_name ?? null,
+          token_count: msg.token_count ?? prev.token_count ?? null,
+          ...(terminal ? { summary: msg.summary ?? '' } : {}),
+        },
+        itemStatus,
+      );
+    } else {
+      insertItem(
+        db,
+        this.deps.agentPaneSessionId,
+        this.deps.turnId,
+        externalId,
+        'background_task',
+        {
+          task_id: msg.task_id,
+          description: msg.description,
+          task_type: 'subagent',
+          subagent_type: msg.agent_name,
+          prompt: null,
+          status: terminal ? msg.event : 'running',
+          summary: terminal ? msg.summary ?? '' : null,
+          output_file: null,
+          output: '',
+          token_count: msg.token_count ?? null,
+          last_tool_name: msg.last_tool_name ?? null,
+        },
+        itemStatus,
+        terminal ? 'item:completed' : 'item:started',
+      );
+    }
+    this.touch();
+  }
+private handleResult(msg: ResultMessage): void {
     switch (msg.subtype) {
       case 'success':
         this.finishSuccess(msg);
@@ -315,6 +411,9 @@ export class TurnProjector {
       turnId: this.deps.turnId,
       ...(usage ? { usage } : {}),
       hasUnreviewed: true,
+      // Final text — the FE renders it when the turn has no agent_message
+      // item (final-action rounds).
+      response: responseText || null,
     });
     void this.syncTitle();
     this.finalize();
@@ -464,6 +563,7 @@ export class TurnProjector {
           turnId: this.deps.turnId,
           ...(usage ? { usage } : {}),
           hasUnreviewed: true,
+          response: responseText || null,
         });
         void this.syncTitle();
         this.finalize();