repoburg 1.3.201 → 1.3.202

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

@@ -193,6 +193,12 @@ function createTables(database: Database.Database): void {
     database.exec('ALTER TABLE turns ADD COLUMN attachments TEXT');
   }
 
+  // Migration: add 'runtime_input_ids' column to turns table (repoburg rewind
+  // anchor mapping — JSON array of the runtime input ids composing the turn)
+  if (!turnColumns.some((c) => c.name === 'runtime_input_ids')) {
+    database.exec('ALTER TABLE turns ADD COLUMN runtime_input_ids TEXT');
+  }
+
   // Migration: add 'external_thread_id' column to discussion_threads (thread branching)
   const threadColumns = database.prepare('PRAGMA table_info(discussion_threads)').all() as { name: string }[];
   if (!threadColumns.some((c) => c.name === 'external_thread_id')) {

package/agent-pane/backend/src/providers/runtime-provider.ts

@@ -29,6 +29,12 @@ export interface RuntimeProvider {
    *  Returns the new provider-native session ID, or null if there is no thread to fork.
    *  Optional — providers without fork support omit it. */
   forkSession?(session: Session, targetTurn: Turn): Promise<string | null>;
+  /** Truncate the runtime session's history IN PLACE after the target turn
+   *  (platform-parity rewind: hard delete). Throws on failure — the caller
+   *  must NOT apply any local rewind when this fails.
+   *  Optional — providers without in-place truncation omit it (e.g. Claude
+   *  uses forkSession instead). */
+  rewindRuntime?(session: Session, targetTurn: Turn): Promise<void>;
   /** Change the model for a running session without restarting the CLI process.
    *  Only supported in streaming-input mode (Claude). If the session hasn't
    *  started yet, the new model is read from the DB on next startTurn.

package/agent-pane/backend/src/repoburg/action-mapping.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest';
+import { mapActionToItem, parseSelectionGroups } from './action-mapping.ts';
+import type { RepoburgAction } from './repoburg-client.ts';
+
+function askUserAction(selections: string | null): RepoburgAction {
+  return {
+    id: 'a1',
+    action_type: 'ask_user',
+    status: 'CONFIRMED_KEPT',
+    selections,
+    order_of_execution: 0,
+  };
+}
+
+function subagentAction(status: string, output = ''): RepoburgAction {
+  return {
+    id: 'act-1',
+    action_type: 'invoke_subagent',
+    status,
+    arguments: JSON.stringify({ agent_name: 'explore-codebase', prompt: 'Find auth files' }),
+    order_of_execution: 0,
+    executionLogs: [{ output }],
+  };
+}
+
+describe('mapActionToItem — invoke_subagent', () => {
+  it('maps to a completed background_task card (snapshot/reload shape)', () => {
+    const mapped = mapActionToItem(subagentAction('CONFIRMED_KEPT', 'auth files found'));
+    expect(mapped).not.toBeNull();
+    expect(mapped!.type).toBe('background_task');
+    expect(mapped!.status).toBe('completed');
+    expect(mapped!.data).toMatchObject({
+      task_type: 'subagent',
+      subagent_type: 'explore-codebase',
+      description: 'Find auth files',
+      status: 'completed',
+      summary: 'auth files found',
+      last_tool_name: null,
+      token_count: null,
+    });
+  });
+
+  it('maps a failed invoke_subagent to a failed background_task with the error as summary', () => {
+    const action = {
+      ...subagentAction('EXECUTION_FAILED'),
+      executionLogs: [{ error_message: 'boom' }],
+    };
+    const mapped = mapActionToItem(action);
+    expect(mapped!.status).toBe('failed');
+    expect(mapped!.data).toMatchObject({ status: 'failed', summary: 'boom' });
+  });
+});
+describe('parseSelectionGroups', () => {
+  it('parses canonical [{question, selections[]}] groups', () => {
+    const raw = JSON.stringify([
+      { question: 'Which database?', selections: ['Postgres', 'SQLite'] },
+      { question: 'Proceed?', selections: ['yes', 'no'] },
+    ]);
+    expect(parseSelectionGroups(raw)).toEqual([
+      { question: 'Which database?', selections: ['Postgres', 'SQLite'] },
+      { question: 'Proceed?', selections: ['yes', 'no'] },
+    ]);
+  });
+
+  it('coerces flat string arrays into single-option groups', () => {
+    expect(parseSelectionGroups(JSON.stringify(['Yes', 'No']))).toEqual([
+      { question: '', selections: ['Yes'] },
+      { question: '', selections: ['No'] },
+    ]);
+  });
+
+  it('drops invalid entries and non-string options', () => {
+    const raw = JSON.stringify([
+      { question: 'Q', selections: ['ok', 42] },
+      null,
+      { question: 'No options', selections: [] },
+    ]);
+    expect(parseSelectionGroups(raw)).toEqual([{ question: 'Q', selections: ['ok'] }]);
+  });
+
+  it('returns [] for malformed JSON, null, and non-array payloads', () => {
+    expect(parseSelectionGroups('not json')).toEqual([]);
+    expect(parseSelectionGroups(null)).toEqual([]);
+    expect(parseSelectionGroups('{"question":"q"}')).toEqual([]);
+  });
+});
+
+describe('mapActionToItem — ask_user', () => {
+  it('maps to an ask_user item with parsed groups', () => {
+    const raw = JSON.stringify([
+      { question: 'Which database?', selections: ['Postgres', 'SQLite'] },
+    ]);
+    const mapped = mapActionToItem(askUserAction(raw));
+    expect(mapped).not.toBeNull();
+    expect(mapped!.type).toBe('ask_user');
+    expect(mapped!.status).toBe('completed');
+    expect(mapped!.data).toEqual({
+      question: '',
+      groups: [{ question: 'Which database?', selections: ['Postgres', 'SQLite'] }],
+    });
+  });
+
+  it('falls back to a plain-text question card on malformed selections', () => {
+    const mapped = mapActionToItem(askUserAction('Plain question?'));
+    expect(mapped).not.toBeNull();
+    expect(mapped!.type).toBe('ask_user');
+    expect(mapped!.data).toEqual({ question: 'Plain question?', groups: [] });
+  });
+
+  it('maps without selections to a question card with the raw payload as text', () => {
+    const mapped = mapActionToItem(askUserAction('Which one?\n["A","B"]'));
+    expect(mapped).not.toBeNull();
+    expect(mapped!.data).toEqual({ question: 'Which one?\n["A","B"]', groups: [] });
+  });
+
+  it('maps a failed ask_user action to a failed item', () => {
+    const raw = JSON.stringify([{ question: 'Q?', selections: ['a', 'b'] }]);
+    const action = { ...askUserAction(raw), status: 'EXECUTION_FAILED' };
+    const mapped = mapActionToItem(action);
+    expect(mapped!.status).toBe('failed');
+  });
+});

package/agent-pane/backend/src/repoburg/action-mapping.ts

@@ -9,6 +9,7 @@ import { v4 as uuidv4 } from 'uuid';
 import type Database from 'better-sqlite3';
 import { broadcast } from '../ws/index.ts';
 import type { Item, ItemStatus } from '../db/schema.ts';
+import type { AskUserSelectionGroup, AskUserItemData } from '@agentpane/shared';
 import type { RepoburgAction } from './repoburg-client.ts';
 
 /** Safely parse a JSON string field from an action row. */
@@ -22,6 +23,42 @@ export function parseJsonArgs(raw: string | null | undefined): Record<string, un
   }
 }
 
+/** Parse a raw selections JSON string into validated groups (platform parity:
+ *  ActionItemContent.parseSelectionGroups). Never throws; flat-string arrays
+ *  coerce into single-option groups; invalid entries are dropped. */
+export function parseSelectionGroups(raw: string | null | undefined): AskUserSelectionGroup[] {
+  if (!raw) return [];
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  return parsed
+    .map((item): AskUserSelectionGroup | null => {
+      if (item && typeof item === 'object' && !Array.isArray(item)) {
+        const obj = item as Record<string, unknown>;
+        if (Array.isArray(obj.selections)) {
+          const opts = obj.selections.filter((s): s is string => typeof s === 'string');
+          if (opts.length > 0) {
+            return {
+              question: typeof obj.question === 'string' ? obj.question : '',
+              selections: opts,
+            };
+          }
+        }
+        return null;
+      }
+      // Graceful coercion: flat string → single-option group.
+      if (typeof item === 'string') {
+        return { question: '', selections: [item] };
+      }
+      return null;
+    })
+    .filter((g): g is AskUserSelectionGroup => g !== null);
+}
+
 /** Map a repoburg AIAction (+ its first execution log) to an agent-pane item
  *  shape. Returns null for actions that carry no displayable content
  *  (final/html_final — their text is part of the LLM response). */
@@ -69,19 +106,26 @@ export function mapActionToItem(
       };
 
     case 'invoke_subagent': {
+      // background_task completed form — Claude-provider data shape. Serves
+      // snapshot reconcile + reload; the live projector finalizes the same
+      // card through the identical external id `<inputId>-action-<actionId>`.
       const args = parseJsonArgs(action.arguments);
+      const agentName = (args?.agent_name as string) ?? (args?.agentName as string) ?? 'Sub-agent';
+      const prompt = (args?.prompt as string) ?? '';
       return {
-        type: 'mcp_tool_call',
+        type: 'background_task',
         data: {
-          server: null,
-          tool: 'Agent',
-          arguments: {
-            description: (args?.agent_name as string) ?? (args?.agentName as string) ?? 'Subagent',
-            prompt: (args?.prompt as string) ?? '',
-          },
-          result: output ? [{ type: 'text', text: output }] : null,
-          error: failed ? errorMsg || 'Sub-agent failed' : null,
-          status,
+          task_id: (args?.childSessionId as string) ?? '',
+          description: prompt || agentName,
+          task_type: 'subagent',
+          subagent_type: agentName,
+          prompt: prompt || null,
+          status: failed ? 'failed' : 'completed',
+          summary: output || (failed ? errorMsg || 'Sub-agent failed' : ''),
+          output_file: null,
+          output: '',
+          token_count: null,
+          last_tool_name: null,
         },
         status,
       };
@@ -92,9 +136,23 @@ export function mapActionToItem(
       return { type: 'web_search', data: { query: (args?.query as string) ?? '' }, status };
     }
 
+    case 'ask_user': {
+      // Rendered as clickable selection buttons in the frontend.
+      // Malformed payload → fallback plain-text question card.
+      const groups = parseSelectionGroups(action.selections);
+      const data: AskUserItemData = {
+        question: groups.length ? '' : (action.selections ?? ''),
+        groups,
+      };
+      return {
+        type: 'ask_user',
+        data: { question: data.question, groups: data.groups },
+        status,
+      };
+    }
+
     case 'final':
     case 'html_final':
-    case 'ask_user':
       // Their text is part of the LLM response — no separate item.
       return null;
 
@@ -138,6 +196,26 @@ export function mapUsage(u: {
   };
 }
 
+/** Update an item's data + status and broadcast the updated item. */
+export function updateItem(
+  db: Database.Database,
+  sessionId: string,
+  turnId: string,
+  item: Item,
+  data: Record<string, unknown>,
+  status: ItemStatus,
+): void {
+  const now = new Date().toISOString();
+  db.prepare('UPDATE items SET data = ?, status = ?, updated_at = ? WHERE id = ?').run(
+    JSON.stringify(data),
+    status,
+    now,
+    item.id,
+  );
+  const updated: Item = { ...item, data, status, updated_at: now };
+  broadcast('item:updated', { sessionId, turnId, item: updated });
+}
+
 /** Update the running state and status of a session. */
 export function setSessionStatus(
   db: Database.Database,

package/agent-pane/backend/src/repoburg/agent-runtime-client.ts

@@ -30,6 +30,8 @@ export interface AgentRuntimeActionInfo {
   tool_name: string | null;
   arguments: string | null;
   plain: string | null;
+  /** Raw selections JSON string (ask_user/final) — parsed by the client. */
+  selections: string | null;
   order_of_execution: number;
 }
 
@@ -80,6 +82,26 @@ export interface UserMessage {
   content: AgentRuntimeToolResultBlock[];
 }
 
+/** Sub-agent lifecycle event on the PARENT session channel (Claude task
+ *  parity) — compact; child content never crosses the wire. */
+export interface SubagentMessage {
+  type: 'subagent';
+  /** PARENT session id (routing). */
+  sessionId: string;
+  event: 'started' | 'progress' | 'completed' | 'failed';
+  /** Child session id — the task identity. */
+  task_id: string;
+  agent_name: string;
+  /** Task prompt on `started`; the child's latest action on `progress`. */
+  description: string;
+  /** Parent input + invoke_subagent action — the card key. */
+  input_id: string;
+  action_id: string;
+  last_tool_name?: string | null;
+  token_count?: number;
+  summary?: string;
+  usage?: AgentRuntimeUsage;
+}
 export interface ResultMessage {
   type: 'result';
   subtype: 'success' | 'error_during_execution' | 'aborted';
@@ -96,6 +118,7 @@ export type AgentRuntimeMessage =
   | StreamEventMessage
   | AssistantMessage
   | UserMessage
+  | SubagentMessage
   | ResultMessage;
 
 // ---------------------------------------------------------------------------

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

@@ -268,4 +268,89 @@ describe('backend-resolver', () => {
     await vi.advanceTimersByTimeAsync(31_000);
     await assertion;
   });
+it('accepts a healthy running backend whose health projectPath matches the workspace', async () => {
+    const abs = path.resolve('/tmp/proj');
+    mockFetchRoutes([
+      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
+      {
+        match: (u) => u === `${DAEMON}/services`,
+        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
+      },
+      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok', projectPath: abs }) },
+    ]);
+
+    const resolved = await resolveBackendUrl('/tmp/proj');
+    expect(resolved?.baseUrl).toBe('http://localhost:3402');
+  });
+
+  it('treats a projectPath mismatch as unhealthy (autoStart=false → null, no restart)', async () => {
+    const abs = path.resolve('/tmp/proj');
+    const fetchMock = mockFetchRoutes([
+      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
+      {
+        match: (u) => u === `${DAEMON}/services`,
+        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
+      },
+      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok', projectPath: '/tmp/other-workspace' }) },
+    ]);
+
+    expect(await resolveBackendUrl('/tmp/proj', { autoStart: false })).toBeNull();
+    expect(fetchMock.mock.calls.some(([u]) => String(u).includes('restart'))).toBe(false);
+  });
+
+  it('restarts a running backend that serves a different workspace, then resolves it', async () => {
+    const abs = path.resolve('/tmp/proj');
+    let servingWrongWorkspace = true;
+    const restartMock = vi.fn();
+    mockFetchRoutes([
+      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
+      {
+        match: (u) => u === `${DAEMON}/services`,
+        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
+      },
+      {
+        match: (u) => u === 'http://localhost:3402/health',
+        respond: () =>
+          servingWrongWorkspace
+            ? jsonResponse({ status: 'ok', projectPath: '/tmp/other-workspace' })
+            : jsonResponse({ status: 'ok', projectPath: abs }),
+      },
+      {
+        match: (u, m) => u === `${DAEMON}/services/proj/restart` && m === 'POST',
+        respond: () => {
+          restartMock();
+          servingWrongWorkspace = false;
+          return jsonResponse(service({ path: abs, port: 3402, name: 'proj' }));
+        },
+      },
+    ]);
+
+    const resolved = await resolveBackendUrl('/tmp/proj');
+    expect(restartMock).toHaveBeenCalledTimes(1);
+    expect(resolved?.baseUrl).toBe('http://localhost:3402');
+  });
+
+  it('re-consults the daemon when the cached backend starts serving a different workspace', async () => {
+    const abs = path.resolve('/tmp/proj');
+    let projectPath = abs;
+    const fetchMock = mockFetchRoutes([
+      { match: (u) => u === `${DAEMON}/health`, respond: () => jsonResponse({ status: 'ok' }) },
+      {
+        match: (u) => u === `${DAEMON}/services`,
+        respond: () => jsonResponse([service({ path: abs, port: 3402, name: 'proj' })]),
+      },
+      { match: (u) => u === 'http://localhost:3402/health', respond: () => jsonResponse({ status: 'ok', projectPath }) },
+    ]);
+
+    // First resolve caches the backend (projectPath matches).
+    await resolveBackendUrl('/tmp/proj');
+
+    // The row got mis-mapped — the backend now serves another workspace.
+    projectPath = '/tmp/other-workspace';
+    fetchMock.mockClear();
+    await resolveBackendUrl('/tmp/proj', { autoStart: false });
+    // The cache was rejected and the daemon re-consulted (health probe rejected).
+    expect(fetchMock.mock.calls.some(([u]) => String(u) === 'http://localhost:3402/health')).toBe(true);
+    expect(fetchMock.mock.calls.some(([u]) => String(u) === `${DAEMON}/services`)).toBe(true);
+  });
 });

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

@@ -32,6 +32,12 @@ export interface DaemonService {
   pid: number | null;
 }
 
+/** Root backend /health payload (projectPath is additive — absent on pre-v2 builds). */
+interface HealthPayload {
+  status: string;
+  projectPath?: string;
+}
+
 /** A resolved backend instance to connect to. */
 export interface ResolvedBackend {
   baseUrl: string;
@@ -124,21 +130,29 @@ export function invalidateBackend(baseUrl: string): void {
   }
 }
 
-/** Probe a backend's /health endpoint (short timeout). */
-async function backendHealthy(baseUrl: string): Promise<boolean> {
+/**
+ * Probe a backend's /health endpoint (short timeout). With expectedPath, a
+ * projectPath mismatch means unhealthy: the backend serves a different
+ * workspace than the daemon row claims (mis-mapped service).
+ */
+async function backendHealthy(baseUrl: string, expectedPath?: string): Promise<boolean> {
   try {
-    await fetchJson(`${baseUrl}/health`, undefined, 2000);
+    const health = await fetchJson<HealthPayload>(`${baseUrl}/health`, undefined, 2000);
+    if (health.status !== 'ok') return false;
+    if (expectedPath && health.projectPath) {
+      return path.resolve(health.projectPath) === path.resolve(expectedPath);
+    }
     return true;
   } catch {
     return false;
   }
 }
 
-/** Wait until the backend on baseUrl reports healthy. */
-async function waitForHealthy(baseUrl: string, name: string): Promise<void> {
+/** Wait until the backend on baseUrl reports healthy (for expectedPath). */
+async function waitForHealthy(baseUrl: string, name: string, expectedPath?: string): Promise<void> {
   const deadline = Date.now() + HEALTH_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    if (await backendHealthy(baseUrl)) return;
+    if (await backendHealthy(baseUrl, expectedPath)) return;
     await new Promise((resolve) => setTimeout(resolve, HEALTH_POLL_INTERVAL_MS));
   }
   throw new Error(
@@ -202,9 +216,9 @@ export async function resolveBackendUrl(
   const absPath = path.resolve(projectPath);
   const daemon = daemonBaseUrl();
 
-  // 2. Cached resolution, re-verified healthy.
+  // 2. Cached resolution, re-verified healthy (and serving this workspace).
   const cached = resolvedCache.get(absPath);
-  if (cached && (await backendHealthy(cached.baseUrl))) {
+  if (cached && (await backendHealthy(cached.baseUrl, absPath))) {
     return cached;
   }
 
@@ -221,13 +235,14 @@ export async function resolveBackendUrl(
   const match = services.find((s) => s.path === absPath);
 
   if (match && match.status === 'running') {
-    if (await backendHealthy(serviceBaseUrl(match))) {
+    if (await backendHealthy(serviceBaseUrl(match), absPath)) {
       return cache(absPath, match);
     }
     if (!autoStart) return null;
-    // Healthy check failed — the process died. Restart via the daemon.
+    // Unhealthy or serving a different workspace — the process is wrong
+    // for this path. Restart via the daemon.
     await restartService(daemon, match.name);
-    await waitForHealthy(serviceBaseUrl(match), match.name);
+    await waitForHealthy(serviceBaseUrl(match), match.name, absPath);
     return cache(absPath, match);
   }
 
@@ -235,12 +250,12 @@ export async function resolveBackendUrl(
 
   if (match) {
     await restartService(daemon, match.name);
-    await waitForHealthy(serviceBaseUrl(match), match.name);
+    await waitForHealthy(serviceBaseUrl(match), match.name, absPath);
     return cache(absPath, match);
   }
 
   // No service for this path yet — start one.
   const service = await startService(daemon, absPath);
-  await waitForHealthy(serviceBaseUrl(service), service.name);
+  await waitForHealthy(serviceBaseUrl(service), service.name, absPath);
   return cache(absPath, service);
 }

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

@@ -130,6 +130,27 @@ describe('RepoburgHttpClient (HTTP control surface)', () => {
 
     expect(models).toEqual([]);
   });
+it('deleteInputsUntilHere DELETEs the anchor until-here endpoint (204 empty body)', async () => {
+    // The root endpoint replies 204 No Content — must resolve, not throw.
+    fetchMock.mockResolvedValue({ ok: true, status: 204, text: () => Promise.resolve('') } as never);
+
+    await client.deleteInputsUntilHere('rs-1', 'in-9');
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'http://repoburg.test/sessions/rs-1/inputs/in-9/until-here',
+      expect.objectContaining({ method: 'DELETE', body: undefined }),
+    );
+  });
+
+  it('deleteInputsUntilHere surfaces the 400 summary-in-range error', async () => {
+    fetchMock.mockResolvedValue(
+      error(400, { message: 'Summaries can only be discarded, not deleted.' }),
+    );
+
+    await expect(client.deleteInputsUntilHere('rs-1', 'in-9')).rejects.toThrow(
+      'DELETE /sessions/rs-1/inputs/in-9/until-here failed: 400 {"message":"Summaries can only be discarded, not deleted."}',
+    );
+  });
 
   it('throws with status + body text on non-OK responses', async () => {
     fetchMock.mockResolvedValue(error(400, 'Bad request'));

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

@@ -60,6 +60,8 @@ export interface RepoburgAction {
   tool_name?: string | null;
   arguments?: string | null;
   plain?: string | null;
+  /** Raw selections JSON string (ask_user/final) — parsed by the client. */
+  selections?: string | null;
   reason?: string | null;
   order_of_execution?: number;
   executionLogs?: RepoburgExecutionLog[];
@@ -88,6 +90,8 @@ export interface RepoburgRuntimeClient {
   getInputWithActions(sessionId: string, inputId: string): Promise<RepoburgSessionInput>;
   /** Full snapshot: all inputs of the session with actions + logs (ASC). */
   getSessionInputs(sessionId: string): Promise<RepoburgSessionInput[]>;
+  /** Hard-delete every input AFTER the anchor (platform rewind parity). */
+  deleteInputsUntilHere(sessionId: string, anchorInputId: string): Promise<void>;
   cancel(sessionId: string): Promise<{ success: boolean; cancelled: boolean }>;
   getModels(): Promise<RepoburgModel[]>;
 }
@@ -131,6 +135,8 @@ export class RepoburgHttpClient implements RepoburgRuntimeClient {
       }
       throw new Error(`${method} ${path} failed: ${response.status} ${text}`);
     }
+    // Success with no payload — e.g. 204 No Content from the until-here delete.
+    if (text.length === 0) return undefined as unknown as T;
     try {
       return JSON.parse(text) as T;
     } catch {
@@ -167,6 +173,13 @@ export class RepoburgHttpClient implements RepoburgRuntimeClient {
     return this.request<RepoburgSessionInput[]>('GET', `/sessions/${sessionId}/inputs`);
   }
 
+  async deleteInputsUntilHere(sessionId: string, anchorInputId: string): Promise<void> {
+    await this.request<unknown>(
+      'DELETE',
+      `/sessions/${sessionId}/inputs/${anchorInputId}/until-here`,
+    );
+  }
+
   async cancel(sessionId: string): Promise<{ success: boolean; cancelled: boolean }> {
     return this.request<{ success: boolean; cancelled: boolean }>(
       'POST',