ompchamber 3.3.2 → 3.4.0

package/src/server/lib/assets/font-faces.ts

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Pulling `@font-face` blocks out of a stylesheet, and pointing their `url()`s
+ * at the served route.
+ *
+ * Two callers, one reason to share: the bundler's CSS loader strips faces out
+ * of every module it bundles (`lib/bundler/css.ts`) because Bun resolves each
+ * local `url()` into base64 or an absolute filesystem path, and the server
+ * assembles `/fonts.css` from the same stylesheets
+ * (`lib/assets/font-css.server.ts`). The two must agree byte for byte — a face
+ * stripped from the bundle has to be the one the stylesheet re-declares, or the
+ * font silently never loads.
+ *
+ * Only a block whose `src` names a LOCAL font moves: a face pointing at a
+ * remote url is valid CSS the bundle can keep. `rewriteFontUrls` replaces every
+ * local font url with `<FONT_ROUTE_PREFIX><basename>`, which is the only form
+ * that survives Bun's loader — a same-origin path is not an escape hatch, since
+ * `url("/fonts/x.woff2")` fails the build with "Could not resolve".
+ */
+
+import { basename, isAbsolute, resolve as resolvePath } from 'path';
+
+import { FONT_ROUTE_PREFIX } from '@/server/lib/assets/fonts.server';
+
+/** A `url(...)` whose target is a font file. */
+const URL_FUNCTION = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
+const FONT_FILE = /\.(?:woff2?|ttf|otf)$/i;
+/** Schemes Bun leaves alone, and the prefix this module itself emits. */
+const EXTERNAL = /^(?:data:|https?:|blob:|\/\/)/i;
+
+/** One `@font-face` block, braces included. Faces cannot nest. */
+const FONT_FACE = /@font-face\s*\{[^{}]*\}/g;
+
+/** Absolute path of a local font url, or null when it is not one. */
+function localFont(specifier: string, cssDir: string): string | null {
+  if (EXTERNAL.test(specifier) || specifier.startsWith(FONT_ROUTE_PREFIX)) return null;
+  if (!FONT_FILE.test(specifier)) return null;
+  return isAbsolute(specifier) ? specifier : resolvePath(cssDir, specifier);
+}
+
+/** Point every font `url()` at the served path. */
+export function rewriteFontUrls(css: string, cssDir: string): string {
+  return css.replace(URL_FUNCTION, (whole, quote: string, specifier: string) => {
+    const absolute = localFont(specifier, cssDir);
+    if (!absolute) return whole;
+    return `url(${quote}${FONT_ROUTE_PREFIX}${basename(absolute)}${quote})`;
+  });
+}
+
+/**
+ * Split `@font-face` blocks out of a stylesheet.
+ *
+ * `cssDir` resolves a relative `src` url, so it must be the directory of the
+ * file the text came from — not the bundle's.
+ */
+export function splitFontFaces(css: string, cssDir: string): { rest: string; faces: string[] } {
+  const faces: string[] = [];
+  const rest = css.replace(FONT_FACE, (block) => {
+    const hasLocal = [...block.matchAll(URL_FUNCTION)].some(([, , spec]) => localFont(spec, cssDir));
+    if (!hasLocal) return block;
+    faces.push(rewriteFontUrls(block, cssDir));
+    return '';
+  });
+  return { rest, faces };
+}

package/src/server/lib/assets/fonts.server.ts

@@ -77,12 +77,16 @@ let index: Record<string, string> | null = null;
 /**
  * The package root — the first search root that holds `node_modules`.
  *
- * Both ends of the build need the same answer: the plugin writes the extracted
- * face files here and the server reads them back, and an AOT bundle runs from
- * `dist/client` while a source checkout runs from the repo. Falling back to the
+ * The AOT bundle runs from `dist/client` while a source checkout runs from the
+ * repo, and both resolve their dependencies through this. Falling back to the
  * cwd keeps a checkout with no `node_modules` (a publish dry-run) working.
+ *
+ * This answers "where are the DEPENDENCIES", which is not the same question as
+ * `packageDir()` below: a hoisted install keeps the package's own files under
+ * `node_modules/ompchamber/` while its dependencies sit in the parent
+ * `node_modules/`, so the first root holding `node_modules` is the PARENT.
  */
-export function packageRoot(): string {
+function packageRoot(): string {
   for (const root of searchRoots()) {
     // `existsSync` rather than `Bun.file().exists()`: the latter is async and
     // file-only, and `node_modules` is a directory.
@@ -91,6 +95,25 @@ export function packageRoot(): string {
   return process.cwd();
 }
 
+/**
+ * The package's own directory — the first search root that holds `src/`.
+ *
+ * The source stylesheets `lib/assets/font-css.server.ts` reads for `/fonts.css`
+ * live there, and they must be found in every install shape. In a source
+ * checkout and a non-hoisted install this is the same directory
+ * `packageRoot()` returns; in a hoisted install it is the package under
+ * `node_modules/`, one level BELOW the root that holds the dependencies.
+ * Resolving the source tree through `packageRoot()` there would look for
+ * `src/` beside the hoisted packages and find nothing, which serves an empty
+ * stylesheet and silently drops every `@font-face`.
+ */
+export function packageDir(): string {
+  for (const root of searchRoots()) {
+    if (existsSync(join(root, 'src'))) return root;
+  }
+  return packageRoot();
+}
+
 async function buildIndex(): Promise<Record<string, string>> {
   const found: Record<string, string> = {};
   const glob = new Glob('*.{woff2,woff,ttf,otf}');

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/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 })),
-    ),
   };
 }