ompchamber 3.3.3 → 3.4.0

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

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

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The side reply's stored summary, bounded the way omp bounds its own.
+ *
+ * omp runs every ephemeral side reply through `dedupeEphemeralReply`
+ * (`session/messages.ts`): a run of more than three identical lines collapses to
+ * one line plus `[…N×]`, and the whole reply is capped at 4 KiB with a
+ * `[…truncated]` suffix. The cap exists because a degenerate model can emit
+ * thousands of identical lines, and this summary is what the panel's history
+ * labels and a promotion's title are built from.
+ *
+ * Only the turn's `answer` summary goes through here. The rendered conversation
+ * (`messages`) is stored whole — truncating that would hide content the panel is
+ * there to show.
+ */
+
+/** Longest stored summary, matching omp's `EPHEMERAL_REPLY_MAX_BYTES`. */
+const MAX_REPLY_BYTES = 4096;
+
+/** Runs longer than this collapse to one line plus a count. */
+const MAX_REPEATED_LINES = 3;
+
+export function boundSideReply(text: string): string {
+  if (!text) return text;
+  const lines = text.split('\n');
+  const collapsed: string[] = [];
+  let index = 0;
+  while (index < lines.length) {
+    let next = index + 1;
+    while (next < lines.length && lines[next] === lines[index]) next += 1;
+    const runLength = next - index;
+    if (runLength > MAX_REPEATED_LINES) {
+      collapsed.push(lines[index], `[…${runLength}×]`);
+    } else {
+      for (let repeat = 0; repeat < runLength; repeat += 1) collapsed.push(lines[index]);
+    }
+    index = next;
+  }
+  let result = collapsed.join('\n');
+  if (Buffer.byteLength(result, 'utf8') <= MAX_REPLY_BYTES) return result;
+  const suffix = '\n[…truncated]';
+  const budget = MAX_REPLY_BYTES - Buffer.byteLength(suffix, 'utf8');
+  // Cut by code point: slicing at an arbitrary byte would leave half a surrogate
+  // pair, which JSON-serializes as U+FFFD and never round-trips.
+  while (result.length > 0 && Buffer.byteLength(result, 'utf8') > budget) {
+    const last = result.charCodeAt(result.length - 1);
+    result = result.slice(0, last >= 0xdc00 && last <= 0xdfff ? -2 : -1);
+  }
+  return result + suffix;
+}

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

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `BtwRuntime.retarget` — the path that makes a side question follow the chat's
+ * model and thinking selector.
+ *
+ * A live child keeps the model it was SPAWNED with, so a chat that switched
+ * model between two side questions would otherwise be answered by the stale one.
+ * omp's side turn reads `request.session.model` per run; this is the equivalent,
+ * and it has to be a no-op when the values already match or every question would
+ * spend two RPC round-trips re-sending what the child already runs.
+ *
+ * The child is a real `RpcProcess` here (no omp binary is spawned): only the
+ * command surface is replaced, so the assertions are on the actual commands the
+ * runtime would put on the wire.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { BtwRuntime } from '@/server/lib/btw/runtime.server';
+import type { RpcProcess } from '@/server/lib/omp/rpc/process';
+import type { BtwFrame } from '@/shared/types';
+
+interface SentCommand {
+  type: string;
+  [key: string]: unknown;
+}
+
+/** A runtime whose child is alive and records every command sent to it. */
+function makeRuntime(options: { alive: boolean }): { runtime: BtwRuntime; sent: SentCommand[]; setState: (state: unknown) => void } {
+  const sent: SentCommand[] = [];
+  let state: unknown = { model: { provider: 'kenari', id: 'deepseek-v4' }, thinkingLevel: 'high' };
+  const proc = {
+    get isAlive() {
+      return options.alive;
+    },
+    async sendCommand(command: SentCommand) {
+      sent.push(command);
+      return command.type === 'get_state' ? state : {};
+    },
+    sendFrame: () => {},
+    onFrame: () => () => {},
+    dispose: async () => {},
+  };
+  const runtime = new BtwRuntime(
+    {
+      topicId: 'topic',
+      sessionId: 'session',
+      parentSessionFile: '/tmp/parent.jsonl',
+      cwd: '/tmp',
+      model: { provider: 'kenari', id: 'deepseek-v4' },
+      thinkingLevel: 'high',
+    },
+    { publish: (_frame: BtwFrame) => {}, stateChanged: () => {} },
+  );
+  // `proc` is the private field the runtime reads; the cast is the seam that
+  // keeps this a unit test instead of a spawned-child integration test.
+  (runtime as unknown as { proc: unknown }).proc = proc;
+  return {
+    runtime,
+    sent,
+    setState: (next) => {
+      state = next;
+    },
+  };
+}
+
+describe('BtwRuntime.start', () => {
+  test('reuses the live child instead of spawning a second one', async () => {
+    const { runtime } = makeRuntime({ alive: true });
+    // The seam this suite installs, read back as the type `start` returns.
+    const proc = (runtime as unknown as { proc: RpcProcess }).proc;
+
+    // A live child is returned as-is; `spawnChild` is never reached (it would
+    // throw here, since no omp binary is configured for this unit test).
+    expect(await runtime.start()).toBe(proc);
+  });
+});
+
+describe('BtwRuntime.retarget', () => {
+  test('re-sends both values when the chat moved on', async () => {
+    const { runtime, sent } = makeRuntime({ alive: true });
+    // Seed what the child currently reports (as `captureModel` would).
+    await runtime.retarget({ provider: 'kenari', id: 'deepseek-v4' }, 'high');
+    sent.length = 0;
+
+    await runtime.retarget({ provider: 'anthropic', id: 'claude-sonnet-5' }, 'low');
+
+    expect(sent.map((command) => command.type)).toEqual(['set_model', 'set_thinking_level']);
+    expect(sent[0]).toMatchObject({ provider: 'anthropic', modelId: 'claude-sonnet-5' });
+    expect(sent[1]).toMatchObject({ level: 'low' });
+  });
+
+  test('sends nothing when the child already runs them', async () => {
+    const { runtime, sent } = makeRuntime({ alive: true });
+    await runtime.retarget({ provider: 'kenari', id: 'deepseek-v4' }, 'high');
+    sent.length = 0;
+
+    await runtime.retarget({ provider: 'kenari', id: 'deepseek-v4' }, 'high');
+
+    expect(sent).toHaveLength(0);
+  });
+
+  test('records the values for the next spawn when no child is alive', async () => {
+    const { runtime, sent } = makeRuntime({ alive: false });
+
+    await runtime.retarget({ provider: 'anthropic', id: 'claude-sonnet-5' }, 'auto');
+
+    expect(sent).toHaveLength(0);
+    // The spawn reads these; nothing was sent to a dead process.
+    expect((runtime as unknown as { context: { model?: unknown; thinkingLevel?: string } }).context.model)
+      .toEqual({ provider: 'anthropic', id: 'claude-sonnet-5' });
+    expect((runtime as unknown as { context: { thinkingLevel?: string } }).context.thinkingLevel).toBe('auto');
+  });
+
+  test('carries `auto` through to the child rather than dropping it', async () => {
+    const { runtime, sent } = makeRuntime({ alive: true });
+    await runtime.retarget(undefined, 'high');
+    sent.length = 0;
+
+    await runtime.retarget(undefined, 'auto');
+
+    expect(sent.map((command) => command.type)).toEqual(['set_thinking_level']);
+    expect(sent[0]).toMatchObject({ level: 'auto' });
+  });
+});