ompchamber 3.3.3 → 3.5.0

package/src/client/hooks/workspace/session-delete.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Session deletion, shared by the desktop session row and the mobile one.
+ *
+ * Both sidebars render the same confirmation dialog and issue the same request,
+ * so the state machine (which row is pending, in-flight, why it was refused)
+ * lives here rather than in two components that would drift on the URL, the
+ * verb, or the event they dispatch afterwards.
+ *
+ * Two follow-ups are load-bearing and both happen only on success:
+ *
+ *   - `omp:workspace-updated` refreshes the sidebar list. The deleted row is
+ *     gone from disk, but the client still holds the previous snapshot.
+ *   - when the deleted session is the one on screen, `?sessionId=` is dropped.
+ *     Leaving the URL pointing at a removed session renders the chat's "not
+ *     found" state over a row the user just deleted, and every panel keyed to
+ *     that id keeps fetching for it.
+ */
+
+import { useCallback, useState } from 'preact/hooks';
+import { useSearchParams } from '@/client/lib/router/search-params';
+import { forgetSession } from '@/shared/lib/workspace/session-state/store';
+import type { SessionItemData } from '@/shared/types';
+
+export interface SessionDeleteActions {
+  /** The session awaiting confirmation, or null when the dialog is closed. */
+  pending: SessionItemData | null;
+  /** True while the DELETE request is in flight. */
+  isDeleting: boolean;
+  /** The server's refusal reason, shown inside the dialog. */
+  error: string | null;
+  /** Open the confirmation for this session. */
+  requestDelete: (session: SessionItemData) => void;
+  /** Close it without deleting. */
+  cancelDelete: () => void;
+  /** Issue the delete. Resolves once the request settled. */
+  confirmDelete: () => Promise<void>;
+}
+
+export function useSessionDelete(): SessionDeleteActions {
+  const [pending, setPending] = useState<SessionItemData | null>(null);
+  const [isDeleting, setIsDeleting] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [searchParams, setSearchParams] = useSearchParams();
+
+  const requestDelete = useCallback((session: SessionItemData) => {
+    setError(null);
+    setPending(session);
+  }, []);
+
+  const cancelDelete = useCallback(() => {
+    setError(null);
+    setPending(null);
+  }, []);
+
+  const confirmDelete = useCallback(async () => {
+    if (!pending || isDeleting) return;
+    const sessionId = String(pending.id);
+    setIsDeleting(true);
+    setError(null);
+    try {
+      const res = await fetch(`/api/sessions/${encodeURIComponent(sessionId)}`, { method: 'DELETE' });
+      const body = (await res.json().catch(() => null)) as { error?: string } | null;
+      if (!res.ok) {
+        // The refusal reasons the server gives (mid-run, pending chat) are
+        // actionable, so they stay on screen instead of closing the dialog.
+        setError(body?.error || `Could not delete the session (HTTP ${res.status}).`);
+        return;
+      }
+      forgetSession(sessionId);
+      if (searchParams.get('sessionId') === sessionId) {
+        setSearchParams((prev) => {
+          const next = new URLSearchParams(prev);
+          next.delete('sessionId');
+          // A subagent transcript belongs to the session being removed.
+          next.delete('subagent');
+          return next;
+        }, { replace: true });
+      }
+      setPending(null);
+      window.dispatchEvent(new CustomEvent('omp:workspace-updated'));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Could not reach the server.');
+    } finally {
+      setIsDeleting(false);
+    }
+  }, [pending, isDeleting, searchParams, setSearchParams]);
+
+  return { pending, isDeleting, error, requestDelete, cancelDelete, confirmDelete };
+}

package/src/server/lib/btw/child.server.test.ts

@@ -0,0 +1,68 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The side child's argv.
+ *
+ * `--no-tools` is the parity contract: omp's own `/btw` runs the side turn with
+ * the tool catalog attached only for prompt-cache warmth and DISCARDS any tool
+ * call, so a child here that could execute one would be answering a different
+ * question. `--approval-mode` is deliberately absent — with no tool surface it
+ * would govern nothing.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { buildBtwSpawnArgs } from '@/server/lib/btw/child.server';
+import { buildBtwPrompt } from '@/server/lib/btw/prompt';
+
+describe('buildBtwSpawnArgs', () => {
+  test('resumes the transcript without tools or a title', () => {
+    expect(buildBtwSpawnArgs('/tmp/topic.jsonl', {})).toEqual([
+      '--resume',
+      '/tmp/topic.jsonl',
+      '--no-title',
+      '--no-tools',
+    ]);
+  });
+
+  test('carries the chat model and thinking selector', () => {
+    expect(buildBtwSpawnArgs('/tmp/topic.jsonl', {
+      model: { provider: 'kenari', id: 'deepseek-v4' },
+      thinkingLevel: 'high',
+    })).toEqual([
+      '--resume',
+      '/tmp/topic.jsonl',
+      '--no-title',
+      '--no-tools',
+      '--model',
+      'kenari/deepseek-v4',
+      '--thinking',
+      'high',
+    ]);
+  });
+
+  test('passes auto through rather than dropping it', () => {
+    expect(buildBtwSpawnArgs('/tmp/topic.jsonl', { thinkingLevel: 'auto' })).toContain('auto');
+  });
+
+  test('never passes an approval mode', () => {
+    expect(buildBtwSpawnArgs('/tmp/topic.jsonl', { model: { provider: 'p', id: 'm' } })).not.toContain('--approval-mode');
+  });
+});
+
+describe('buildBtwPrompt', () => {
+  test("is omp's own template, tool prohibition included", () => {
+    expect(buildBtwPrompt('what is this?')).toBe([
+      '<btw>',
+      'Ephemeral side question for current interactive session.',
+      'Answer briefly, directly; use conversation context already provided.',
+      'NEVER use tools.',
+      'NEVER ask follow-up questions.',
+      'Question:',
+      'what is this?',
+      '</btw>',
+    ].join('\n'));
+  });
+});

package/src/server/lib/btw/child.server.ts

@@ -7,35 +7,36 @@
  * Spawn arguments for a topic's side child.
  *
  * The side child is an ordinary `omp --mode rpc-ui` that resumes the topic's
- * transcript. It runs WITH tools (unlike the TUI's `/btw`, which passes
- * `--no-tools`): the panel exposes a real access-control dropdown, and an
- * approval mode that governs nothing is a lie in the UI. What the child may
- * actually do is therefore the `--approval-mode` flag's business, exactly as it
- * is for a chat session.
+ * transcript, run with `--no-tools`: a side question answers from the context it
+ * already has and never executes a tool. That is omp's own rule — its TUI `/btw`
+ * runs the side turn through `runEphemeralTurn`, which attaches the tool catalog
+ * only to keep the prompt cache warm, tells the model in a system reminder that
+ * tools are NOT available, and discards any tool call the model emits anyway
+ * (`agent-session.ts`).
+ *
+ * `--no-tools` reaches the same end state from the CLI: the tool catalog is
+ * omitted entirely, so a hallucinated call cannot execute and no approval gate
+ * can park the turn. `--approval-mode` therefore has nothing to govern and is
+ * not passed.
  *
  * `--no-title` stays: auto-titling would spend a model call on a transcript
  * nobody lists in the sidebar.
  */
 
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import type { BtwModel } from '@/shared/types';
 
 export interface BtwSpawnSettings {
   model?: BtwModel;
-  /** omp's own default when absent (`auto`). */
+  /** Thinking level for the side child, or undefined for omp's own default. */
   thinkingLevel?: string;
-  /** Spawn-time only: omp exposes no RPC to change the approval mode. */
-  approvalMode?: ApprovalMode;
 }
 
 export function buildBtwSpawnArgs(sessionFile: string, settings: BtwSpawnSettings): string[] {
-  const args = ['--resume', sessionFile, '--no-title'];
+  const args = ['--resume', sessionFile, '--no-title', '--no-tools'];
   if (settings.model) args.push('--model', `${settings.model.provider}/${settings.model.id}`);
-  // 'auto' means "leave omp's level alone" — the same rule the composer applies,
-  // so it is omitted rather than translated into a concrete level.
-  if (settings.thinkingLevel && settings.thinkingLevel !== 'auto') {
-    args.push('--thinking', settings.thinkingLevel);
-  }
-  if (settings.approvalMode) args.push('--approval-mode', settings.approvalMode);
+  // 'auto' is a level omp accepts on the CLI (`CLI_THINKING_LEVELS`), so it is
+  // passed through rather than dropped: the side child must classify its turns
+  // the way the chat does when the chat is in auto mode.
+  if (settings.thinkingLevel) args.push('--thinking', settings.thinkingLevel);
   return args;
 }

package/src/server/lib/btw/frames.test.ts

@@ -22,18 +22,18 @@ describe('finalStatus', () => {
     expect(finalStatus([assistant()])).toBe('complete');
   });
 
-  test('a user abort is cancelled, not failed', () => {
+  test('a user abort is cancelled, not an error', () => {
     expect(finalStatus([assistant({ stopReason: 'aborted' })])).toBe('cancelled');
   });
 
   test('a provider error is a failure, not a completed answer', () => {
-    expect(finalStatus([assistant({ stopReason: 'error' })])).toBe('failed');
+    expect(finalStatus([assistant({ stopReason: 'error' })])).toBe('error');
   });
 
   test('an error carried as flat fields is still a failure', () => {
     // omp writes abnormal stops as flat `errorStatus`/`errorMessage` on the
     // message; a bare `stopReason` check would call this one complete.
-    expect(finalStatus([assistant({ errorMessage: 'upstream 500', errorStatus: 500 })])).toBe('failed');
+    expect(finalStatus([assistant({ errorMessage: 'upstream 500', errorStatus: 500 })])).toBe('error');
   });
 
   test('the newest assistant turn decides', () => {

package/src/server/lib/btw/frames.ts

@@ -29,7 +29,7 @@ export function finalStatus(messages: unknown): BtwTurnStatus {
       const message = messages[index];
       if (isRecord(message) && message.role === 'assistant') {
         if (!turnStoppedAbnormally(message)) return 'complete';
-        return message.stopReason === 'aborted' ? 'cancelled' : 'failed';
+        return message.stopReason === 'aborted' ? 'cancelled' : 'error';
       }
     }
   }

package/src/server/lib/btw/lifecycle.server.test.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The side turn's frame fold.
+ *
+ * These pin the three behaviours that are invisible until a reload: a completed
+ * message is stored as COMPLETE (its thinking stops pulsing, its usage is the
+ * real one), a tool call the model emitted anyway is not rendered as a card for
+ * a tool that never ran, and the stored summary is bounded the way omp bounds
+ * its own side replies.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { boundSideReply } from '@/server/lib/btw/reply';
+import { trackTurnMessage, type BtwLifecycleHost } from '@/server/lib/btw/lifecycle.server';
+import type { ChatMessageData } from '@/shared/types';
+
+function makeHost(): { host: BtwLifecycleHost; frames: string[] } {
+  const frames: string[] = [];
+  const host = {
+    topicId: 'topic',
+    sessionId: 'session',
+    sink: { publish: (frame: { type: string }) => frames.push(frame.type), stateChanged: () => {} },
+    running: true,
+    proc: null,
+    idleTimer: null,
+    abortTimer: null,
+    lastIdleReset: 0,
+    turnIndex: 0,
+    settling: false,
+    messages: [] as ChatMessageData[],
+    activity: '',
+    disposing: null,
+    start: async () => ({} as never),
+    teardownChild: async () => {},
+  } as unknown as BtwLifecycleHost;
+  return { host, frames };
+}
+
+const ASSISTANT_WITH_TOOL_CALL = {
+  type: 'message_end',
+  message: {
+    id: 'm1',
+    role: 'assistant',
+    timestamp: 1,
+    content: [
+      { type: 'thinking', thinking: 'weighing it up' },
+      { type: 'text', text: 'the answer' },
+      { type: 'toolCall', id: 'call_1', name: 'read', input: { path: 'x' } },
+    ],
+    usage: { input: 10, output: 4, totalTokens: 14 },
+  },
+};
+
+describe('trackTurnMessage', () => {
+  test('a completed message is stored as complete, with its usage', () => {
+    const { host } = makeHost();
+    trackTurnMessage(host, ASSISTANT_WITH_TOOL_CALL as never, false);
+
+    const [row] = host.messages;
+    expect(row?.content).toBe('the answer');
+    expect(typeof row?.thinking === 'object' ? row.thinking.isGenerating : undefined).toBe(false);
+    expect(row?.usage?.totalTokens).toBe(14);
+  });
+
+  test('a streaming segment still marks its thinking as generating', () => {
+    const { host } = makeHost();
+    trackTurnMessage(host, {
+      type: 'message_update',
+      message: { id: 'm1', role: 'assistant', timestamp: 1, content: [{ type: 'thinking', thinking: 'still going' }] },
+    } as never);
+
+    const thinking = host.messages[0]?.thinking;
+    expect(typeof thinking === 'object' ? thinking.isGenerating : undefined).toBe(true);
+  });
+
+  test('a tool call the model emitted anyway is not rendered', () => {
+    const { host } = makeHost();
+    trackTurnMessage(host, ASSISTANT_WITH_TOOL_CALL as never, false);
+
+    expect(host.messages[0]?.toolCalls ?? []).toHaveLength(0);
+  });
+
+  test('a toolResult frame never becomes a row', () => {
+    const { host, frames } = makeHost();
+    trackTurnMessage(host, {
+      type: 'message_end',
+      message: { id: 'r1', role: 'toolResult', toolCallId: 'call_1', content: [{ type: 'text', text: 'file body' }] },
+    } as never, false);
+
+    expect(host.messages).toHaveLength(0);
+    expect(frames).toHaveLength(0);
+  });
+
+  test('a same-id frame replaces the streaming row in place', () => {
+    const { host } = makeHost();
+    trackTurnMessage(host, { type: 'message_update', message: { id: 'm1', role: 'assistant', timestamp: 1, content: [{ type: 'text', text: 'half' }] } } as never);
+    trackTurnMessage(host, { type: 'message_end', message: { id: 'm1', role: 'assistant', timestamp: 1, content: [{ type: 'text', text: 'the answer' }] } } as never, false);
+
+    expect(host.messages).toHaveLength(1);
+    expect(host.messages[0]?.content).toBe('the answer');
+  });
+});
+
+describe('boundSideReply', () => {
+  test('a long run of identical lines collapses with a count', () => {
+    const reply = ['same', 'same', 'same', 'same', 'same'].join('\n');
+    expect(boundSideReply(reply)).toBe('same\n[…5×]');
+  });
+
+  test('a run at the limit is left alone', () => {
+    const reply = ['same', 'same', 'same'].join('\n');
+    expect(boundSideReply(reply)).toBe(reply);
+  });
+
+  test('an oversized reply is capped and marked', () => {
+    // Comfortably past the 4 KiB cap: 500 lines averaging ~11 bytes.
+    const reply = Array.from({ length: 500 }, (_, index) => `line number ${index}`).join('\n');
+    const bounded = boundSideReply(reply);
+    expect(bounded.endsWith('\n[…truncated]')).toBe(true);
+    expect(Buffer.byteLength(bounded, 'utf8')).toBeLessThanOrEqual(4096);
+  });
+
+  test('the cap does not split a surrogate pair', () => {
+    // 4-byte characters only: a byte-slice would leave a lone surrogate, which
+    // JSON round-trips as U+FFFD.
+    const reply = '😀'.repeat(1500);
+    const bounded = boundSideReply(reply);
+    expect(bounded).not.toContain('\uFFFD');
+    expect(bounded.endsWith('\n[…truncated]')).toBe(true);
+  });
+
+  test('a short reply is untouched', () => {
+    expect(boundSideReply('just an answer')).toBe('just an answer');
+  });
+});

package/src/server/lib/btw/lifecycle.server.ts

@@ -16,14 +16,13 @@
 
 import type { RpcProcess, RpcFrame } from '@/server/lib/omp/rpc/process';
 import { GET_STATE_TIMEOUT_MS, IDLE_DESTROY_MS, PROMPT_ACK_TIMEOUT_MS } from '@/server/lib/omp/rpc/constants';
-import type { PendingUiDialogs } from '@/server/lib/omp/rpc/pending-ui-dialogs';
 import { buildBtwPrompt } from '@/server/lib/btw/prompt';
+import { boundSideReply } from '@/server/lib/btw/reply';
 import { appendBtwTurn, settleRunningBtwTurns, updateBtwTurn } from '@/server/lib/btw/store.server';
 import type { BtwRuntimeSink } from '@/server/lib/btw/runtime.server';
 import { toChatMessage } from '@/shared/lib/omp/session/mapper';
 import { describeAssistantPhase, describeToolActivity } from '@/shared/lib/chat/timeline/tool-verbs';
 import { isNoticeRow } from '@/shared/lib/chat/notice-row';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import type { AgentImage, BtwTurnStatus, ChatMessageData } from '@/shared/types';
 
 /** Longest an aborted turn may stay unsettled before its child is reclaimed. */
@@ -33,8 +32,6 @@ const ABORT_GRACE_MS = 10_000;
 export interface BtwLifecycleHost {
   readonly topicId: string;
   readonly sink: BtwRuntimeSink;
-  /** Ask/approval dialogs the child is blocked on. */
-  readonly dialogs: PendingUiDialogs;
   /** A question is in flight in this topic. */
   readonly running: boolean;
   proc: RpcProcess | null;
@@ -49,8 +46,6 @@ export interface BtwLifecycleHost {
   /** Last activity phrase published, so repeats are not re-published. */
   activity: string;
   disposing: Promise<void> | null;
-  /** Approval mode the live child was spawned with. */
-  spawnedApprovalMode: ApprovalMode | undefined;
   /** Spawn (or reuse) the child. */
   start(): Promise<RpcProcess>;
   /** Drop the child and everything scoped to it. */
@@ -71,7 +66,7 @@ export async function askSideQuestion(host: BtwLifecycleHost, question: string,
       PROMPT_ACK_TIMEOUT_MS,
     );
   } catch (error) {
-    await settleSideTurn(host, 'failed');
+    await settleSideTurn(host, 'error');
     host.sink.publish({
       type: 'btw_error',
       topicId: host.topicId,
@@ -106,6 +101,29 @@ export async function abortSideTurn(host: BtwLifecycleHost): Promise<void> {
   host.abortTimer = timer;
 }
 
+/**
+ * Drop `toolCall` content blocks from a message.
+ *
+ * omp's own side turn filters them out of its final message
+ * (`agent-session.ts`: `content.filter(block => block.type !== 'toolCall')`)
+ * because the call was never executed. A model that emits one anyway — a
+ * hallucinated call against the tool catalog omp keeps attached for the prompt
+ * cache — must not surface here as a card for a tool that never ran.
+ */
+function withoutToolCalls(record: Record<string, unknown>): Record<string, unknown> {
+  const content = record.content;
+  if (!Array.isArray(content)) return record;
+  const kept = content.filter((block) => !isToolCallBlock(block));
+  if (kept.length === content.length) return record;
+  return { ...record, content: kept };
+}
+
+/** Whether a content block is a tool call — the block shape omp's own filter reads. */
+function isToolCallBlock(block: unknown): boolean {
+  if (!block || typeof block !== 'object' || !('type' in block)) return false;
+  return block.type === 'toolCall';
+}
+
 /**
  * The turn's conversation as it accumulates, in the chat's own shape.
  *
@@ -113,17 +131,24 @@ export async function abortSideTurn(host: BtwLifecycleHost): Promise<void> {
  * accumulated content and its own message id — so a same-id frame replaces the
  * entry in place and a new id appends. That is exactly the upsert the chat
  * timeline's `onMessageUpdate` performs, and keeping it identical is what makes
- * a side answer render through the chat's own `MessageList`: a tool the side
- * child runs shows up here the same way it would in the chat.
+ * a side answer render through the chat's own `MessageList`.
+ *
+ * `streaming` is the chat stream's own distinction, and it matters in two
+ * places: a COMPLETED message is the authoritative copy (it carries the turn's
+ * real usage where the deltas report zeros), and its thinking is no longer
+ * generating — mapping it as a streaming row left every reloaded turn with an
+ * open, pulsing accordion.
  */
-export function trackTurnMessage(host: BtwLifecycleHost, frame: RpcFrame): void {
+export function trackTurnMessage(host: BtwLifecycleHost, frame: RpcFrame, streaming = true): void {
   const raw = frame.message;
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return;
   const record = raw as Record<string, unknown>;
+  // A side turn executes no tool (see `child.server.ts`), so omp emits no
+  // `toolResult` for it. Dropping the role keeps a stray one from becoming a row.
   if (record.role === 'toolResult') return;
   const turnIndex = host.turnIndex;
   if (turnIndex === null) return;
-  const converted = toChatMessage(record);
+  const converted = toChatMessage(withoutToolCalls(record), streaming);
   if (!converted) return;
   const existing = host.messages.findIndex((message) => message.id === converted.id);
   host.messages =
@@ -168,12 +193,9 @@ export async function settleSideTurn(host: BtwLifecycleHost, status: BtwTurnStat
   host.turnIndex = null;
   // `||`, not `??`: a turn that only ran tools has no prose, and the caller
   // passes an empty string rather than undefined — the summary must then fall
-  // through to whatever the conversation does carry.
-  const text = answer || answerText(host.messages, '');
-  // A settled turn has no dialogs left to answer; a stale modal would sit over
-  // an idle panel with nothing behind it.
-  const hadDialogs = host.dialogs.list().length > 0;
-  host.dialogs.clear();
+  // through to whatever the conversation does carry. Bounded the way omp bounds
+  // its own side replies (see `reply.ts`).
+  const text = boundSideReply(answer || answerText(host.messages, ''));
   host.settling = true;
   try {
     await updateBtwTurn(host.topicId, turnIndex, { answer: text, status, messages: host.messages });
@@ -181,7 +203,6 @@ export async function settleSideTurn(host: BtwLifecycleHost, status: BtwTurnStat
     host.settling = false;
     host.messages = [];
     host.sink.stateChanged();
-    if (hadDialogs) host.sink.stateChanged();
   }
 }
 
@@ -189,13 +210,7 @@ export async function settleSideTurn(host: BtwLifecycleHost, status: BtwTurnStat
 export function handleSideChildExit(host: BtwLifecycleHost, stderrTail: string): void {
   const wasRunning = host.running;
   host.proc = null;
-  host.spawnedApprovalMode = undefined;
-  const hadDialogs = host.dialogs.list().length > 0;
-  host.dialogs.clear();
-  if (!wasRunning) {
-    if (hadDialogs) host.sink.stateChanged();
-    return;
-  }
+  if (!wasRunning) return;
   void settleRunningBtwTurns(host.topicId, 'interrupted').then(() => {
     host.turnIndex = null;
     host.messages = [];
@@ -209,7 +224,7 @@ export function handleSideChildExit(host: BtwLifecycleHost, stderrTail: string):
   });
 }
 
-/** Clear the timers and the process, and drop the dialogs that belonged to it. */
+/** Clear the timers and drop the child. */
 export async function teardownSideChild(host: BtwLifecycleHost): Promise<void> {
   // Type-required guards: the fields are `Timeout | null`, `clearTimeout` takes
   // `Timeout | undefined`.
@@ -217,15 +232,10 @@ export async function teardownSideChild(host: BtwLifecycleHost): Promise<void> {
   if (host.abortTimer) clearTimeout(host.abortTimer);
   host.idleTimer = null;
   host.abortTimer = null;
-  const hadDialogs = host.dialogs.list().length > 0;
-  host.dialogs.clear();
-  host.spawnedApprovalMode = undefined;
   const proc = host.proc;
   host.proc = null;
   if (proc) await proc.dispose().catch(() => {});
   host.disposing = null;
-  // A modal whose process is gone must not stay on screen.
-  if (hadDialogs) host.sink.stateChanged();
 }
 
 async function disposeIfUnsettled(host: BtwLifecycleHost): Promise<void> {

package/src/server/lib/btw/prompt.ts

@@ -6,17 +6,12 @@
 /**
  * The side-question prompt.
  *
- * Derived from omp's own `/btw` template
- * (`packages/coding-agent/src/prompts/system/btw-user.md`), with one
- * deliberate divergence: the TUI's `/btw` runs the side child with
- * `--no-tools` and its prompt says "NEVER use tools". The chamber's panel
- * exposes a real access-control dropdown, which only means something when the
- * child HAS a tool surface — so the tool prohibition is dropped and the
- * approval mode governs what the side child may actually do.
- *
- * What is kept is the shape that makes a side question a side question: it
- * answers briefly and directly, and it never opens a follow-up dialogue of its
- * own — follow-ups are explicit user turns.
+ * Byte-for-byte omp's own `/btw` template
+ * (`packages/coding-agent/src/prompts/system/btw-user.md`), including
+ * "NEVER use tools": the side child runs with `--no-tools`, so a tool call is
+ * impossible and the prompt must not invite one. Keeping the template identical
+ * means a side question reads the same in both clients and a model tuned against
+ * one behaves the same in the other.
  *
  * The parent session's history is NOT part of this text: the side session
  * resumes the parent's transcript, so the context arrives as real provider
@@ -28,6 +23,7 @@ export function buildBtwPrompt(question: string): string {
     '<btw>',
     'Ephemeral side question for current interactive session.',
     'Answer briefly, directly; use conversation context already provided.',
+    'NEVER use tools.',
     'NEVER ask follow-up questions.',
     'Question:',
     question,

package/src/server/lib/btw/purge.server.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Deleting a session's side questions.
+ *
+ * A side question is keyed to the parent session but stored outside it — rows
+ * in `btw_topics`/`btw_turns`, a live omp child per topic, and a private
+ * transcript directory under `<db dir>/btw/<sessionId>/<topicId>/`. Deleting
+ * the chat session therefore leaves all three behind unless they are purged
+ * with it: orphan turns still readable in the database, and on disk a full
+ * copy of the very transcript the user just deleted.
+ *
+ * Kept out of `service.server.ts` (which owns the interactive topic
+ * operations) so that file's growth stays attributable.
+ */
+
+import path from 'path';
+import { listBtwTopics, deleteBtwTopic } from '@/server/lib/btw/store.server';
+import { forgetBtwRuntime, getBtwRuntime } from '@/server/lib/btw/registry.server';
+import { getBtwRoot, removeBtwWorkspace, resolveBtwWorkspacePaths } from '@/server/lib/btw/session-copy.server';
+import { isSinglePathSegment } from '@/server/lib/fs/path-segment';
+
+/**
+ * Drop every topic of `sessionId`, its child, its rows, and its workspace.
+ *
+ * `sessionId` MUST name one child of the btw root. The last step below removes
+ * `join(getBtwRoot(), sessionId)` unconditionally, and `join(root, '.')` is
+ * `root` itself — so an id of `.` (or any id with a separator) turns this
+ * per-session purge into "delete every session's side questions on disk". The
+ * route validates its id; this check is the independent second gate, because
+ * this function is reachable on its own and its failure mode is other
+ * sessions' data.
+ */
+export async function purgeBtwForSession(sessionId: string): Promise<number> {
+  if (!isSinglePathSegment(sessionId)) return 0;
+
+  const topics = await listBtwTopics(sessionId);
+  for (const topic of topics) {
+    const runtime = getBtwRuntime(topic.id);
+    if (runtime) {
+      // Disposes the child; a running turn is settled as cancelled rather than
+      // left to write into a transcript this purge is about to remove.
+      await runtime.dispose();
+      forgetBtwRuntime(topic.id);
+    }
+    await deleteBtwTopic(topic.id);
+    await removeBtwWorkspace((await resolveBtwWorkspacePaths(sessionId, topic.id)).dir);
+  }
+  // The per-session directory as a whole: a topic whose row is already gone can
+  // still have a workspace (a crash between the two, a manual row delete).
+  await removeBtwWorkspace(path.join(await getBtwRoot(), sessionId));
+  return topics.length;
+}

package/src/server/lib/btw/registry.server.ts

@@ -20,7 +20,7 @@
 
 import { listBtwTopics, settleRunningBtwTurns } from '@/server/lib/btw/store.server';
 import { BtwRuntime, type BtwRuntimeContext } from '@/server/lib/btw/runtime.server';
-import type { BtwFrame, BtwState, BtwTopic, ExtensionUiDialogRequest } from '@/shared/types';
+import type { BtwFrame, BtwState, BtwTopic } from '@/shared/types';
 
 interface BtwRegistryHost {
   runtimes: Map<string, BtwRuntime>;
@@ -132,14 +132,6 @@ export async function btwStateFor(sessionId: string): Promise<BtwState> {
     topics: repaired,
     runningTopicId: repaired.find((topic) => topic.turns.some((turn) => turn.status === 'running'))?.id ?? null,
     live: liveRuntime?.liveTurn() ?? null,
-    // Dialogs live on the runtime, not in SQLite: they belong to the child
-    // process that raised them, and a child that is gone has none.
-    dialogs: runtimes.flatMap((runtime) =>
-      runtime.dialogs
-        .list()
-        .filter((request) => typeof request.id === 'string')
-        .map((request) => ({ topicId: runtime.topicId, request: request as unknown as ExtensionUiDialogRequest })),
-    ),
   };
 }