ompchamber 0.7.0 → 1.0.0

package/src/server/routes/terminal/ws.ts

@@ -0,0 +1,149 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Terminal WebSocket: the only transport between a terminal panel and its PTY.
+ *
+ * Text frames are JSON control, binary frames are raw PTY bytes in both
+ * directions. The client's first frame is `attach`, which also creates the
+ * shell when the id is new — one round trip, and no separate create endpoint to
+ * race against.
+ *
+ * The upgrade is origin-checked. Browsers happily open a WebSocket to
+ * `localhost` from any page, and there is no preflight to stop them, so a
+ * cross-origin page could otherwise drive a shell on this machine.
+ *
+ * Per-connection state lives on `ws.data`, not in a `WeakMap` keyed by the `ws`
+ * object: Elysia hands a *different* wrapper to `message`/`close` than the one
+ * `open` received (verified on 1.4.30), so a WeakMap lookup finds nothing and
+ * every frame is silently dropped. `ws.data` is the same object throughout.
+ */
+
+import { Elysia, t } from 'elysia';
+import {
+  attachTerminal,
+  closeTerminal,
+  detachTerminal,
+  resizeTerminalDebounced,
+  writeTerminalInput,
+} from '@/server/lib/terminal/runtime.server';
+import { TerminalRuntimeError, type TerminalViewer } from '@/server/lib/terminal/session.server';
+import {
+  decodeClientFrame,
+  encodeServerFrame,
+  isValidTerminalId,
+} from '@/shared/lib/workspace/terminal/protocol';
+
+interface Attachment {
+  id: string;
+  viewer: TerminalViewer;
+  /** One attach per socket; a duplicate would replay the scrollback twice. */
+  attached: boolean;
+}
+
+/** Elysia's ws context, narrowed to the per-connection store this route adds. */
+type TerminalWsData = { params: { terminalId: string }; terminal?: Attachment };
+
+export const terminalWsRoutes = new Elysia({ prefix: '/api/terminal' }).ws('/:terminalId/ws', {
+  params: t.Object({ terminalId: t.String() }),
+
+  beforeHandle({ request, status }) {
+    if (!isSameOriginUpgrade(request)) return status(403, 'Cross-origin terminal upgrade rejected');
+  },
+
+  open(ws) {
+    const data = ws.data as unknown as TerminalWsData;
+    const id = data.params.terminalId;
+    if (!isValidTerminalId(id)) {
+      ws.close();
+      return;
+    }
+    data.terminal = {
+      id,
+      attached: false,
+      viewer: {
+        send(frame) {
+          try {
+            ws.send(frame);
+          } catch {
+            // Socket closed mid-send; the close handler detaches.
+          }
+        },
+      },
+    };
+  },
+
+  async message(ws, raw) {
+    const attachment = (ws.data as unknown as TerminalWsData).terminal;
+    if (!attachment) return;
+
+    // Raw PTY input (keystrokes, paste, mouse reports) — never JSON-escaped.
+    if (raw instanceof Uint8Array) {
+      writeTerminalInput(attachment.id, raw);
+      return;
+    }
+
+    const frame = decodeClientFrame(raw);
+    if (!frame) return;
+
+    if (frame.t === 'resize') {
+      resizeTerminalDebounced(attachment.id, frame.cols, frame.rows);
+      return;
+    }
+
+    if (frame.t === 'close') {
+      closeTerminal(attachment.id);
+      return;
+    }
+
+    if (attachment.attached) return;
+
+    try {
+      const { snapshot, replay } = await attachTerminal(attachment.viewer, {
+        id: attachment.id,
+        cols: frame.cols,
+        rows: frame.rows,
+        root: frame.root,
+        repo: frame.repo,
+        theme: frame.theme,
+      });
+      attachment.attached = true;
+      ws.send(encodeServerFrame({ t: 'ready', ...snapshot, replayBytes: replay.length }));
+      // Ordering is safe without sequence numbers: attach captured the history
+      // and registered this viewer in one synchronous block, so nothing can be
+      // delivered between this frame and the replay that follows it.
+      if (replay.length > 0) ws.send(replay);
+    } catch (error) {
+      const code = error instanceof TerminalRuntimeError ? error.code : 'unknown';
+      const message = error instanceof Error ? error.message : String(error);
+      ws.send(encodeServerFrame({ t: 'error', code, message }));
+    }
+  },
+
+  close(ws) {
+    const data = ws.data as unknown as TerminalWsData;
+    const attachment = data.terminal;
+    if (!attachment) return;
+    data.terminal = undefined;
+    detachTerminal(attachment.viewer, attachment.id);
+  },
+});
+
+/**
+ * A WebSocket upgrade carries the page's `Origin`, and no preflight protects
+ * it. Requests without one (curl, tests) are allowed: they are not a browser
+ * being tricked into dialing localhost.
+ */
+function isSameOriginUpgrade(request: Request): boolean {
+  const origin = request.headers.get('origin');
+  if (!origin) return true;
+  const host = request.headers.get('host');
+  if (!host) return false;
+  try {
+    return new URL(origin).host === host;
+  } catch {
+    return false;
+  }
+}

package/src/shared/lib/chat/ask-questions.test.ts

@@ -0,0 +1,169 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import type { ToolCallData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+import {
+  groupAskFrames,
+  parseAskQuestions,
+  parseAskResult,
+  normalizeAskText,
+} from '@/shared/lib/chat/ask-questions';
+
+function askTool(input: unknown, extra: Partial<ToolCallData> = {}): ToolCallData {
+  return { id: 'call_ask_1', type: 'ask', title: 'ask', name: 'ask', input: input as Record<string, unknown>, ...extra };
+}
+
+function selectFrame(id: string, title: string, options: string[] = ['A', 'B']): ExtensionUiDialogRequest {
+  return { type: 'extension_ui_request', id, method: 'select', title, options };
+}
+
+const THREE_QUESTIONS = {
+  questions: [
+    {
+      id: 'language',
+      header: 'Language',
+      question: 'Which language should we use for this test?',
+      options: [{ label: 'Python', description: 'Use Python for testing' }, { label: 'TypeScript' }],
+      recommended: 0,
+    },
+    { id: 'style', question: 'What answer style do you prefer for testing?', options: [{ label: 'Balanced' }] },
+    { id: 'confirm', question: 'Did this render correctly?', options: [{ label: 'Yes' }, { label: 'No' }] },
+  ],
+};
+
+describe('parseAskQuestions', () => {
+  test('reads every question, not just the first', () => {
+    const questions = parseAskQuestions(askTool(THREE_QUESTIONS));
+    expect(questions.map((q) => q.id)).toEqual(['language', 'style', 'confirm']);
+    expect(questions[0].options[0]).toEqual({ label: 'Python', description: 'Use Python for testing' });
+    expect(questions[0].recommended).toBe(0);
+    expect(questions[1].multi).toBe(false);
+  });
+
+  test('is empty for a non-ask payload, so the card falls back to the raw result', () => {
+    expect(parseAskQuestions(askTool({ question: 'single legacy shape' }))).toEqual([]);
+    expect(parseAskQuestions(askTool(undefined))).toEqual([]);
+  });
+
+  test('drops entries without question text instead of rendering a blank block', () => {
+    const questions = parseAskQuestions(askTool({ questions: [{ id: 'a' }, { id: 'b', question: '  Keep me  ' }] }));
+    expect(questions).toEqual([expect.objectContaining({ id: 'b', question: 'Keep me' })]);
+  });
+});
+
+describe('normalizeAskText', () => {
+  test('strips the progress suffix and the multi-select prefix omp decorates titles with', () => {
+    expect(normalizeAskText('Which language? (2/3)')).toBe('which language?');
+    expect(normalizeAskText('(2 selected) Which language?')).toBe('which language?');
+    expect(normalizeAskText('(1 selected) Pick one (3/3)')).toBe('pick one');
+  });
+});
+
+describe('groupAskFrames', () => {
+  const questions = parseAskQuestions(askTool(THREE_QUESTIONS));
+
+  test('puts each dialog on the question that raised it', () => {
+    const frames = [
+      selectFrame('f1', 'Which language should we use for this test? (1/3)'),
+      selectFrame('f2', 'What answer style do you prefer for testing? (2/3)'),
+      selectFrame('f3', 'Did this render correctly? (3/3)'),
+    ];
+    const groups = groupAskFrames(questions, frames);
+    expect(groups.map((group) => group.map((frame) => frame.id))).toEqual([['f1'], ['f2'], ['f3']]);
+  });
+
+  test('keeps the free-text follow-up dialog on the question that asked for it', () => {
+    const frames: ExtensionUiDialogRequest[] = [
+      selectFrame('f1', 'Which language should we use for this test? (1/3)'),
+      { type: 'extension_ui_request', id: 'f1b', method: 'editor', title: 'Which language should we use for this test?' },
+      selectFrame('f2', 'What answer style do you prefer for testing? (2/3)'),
+    ];
+    const groups = groupAskFrames(questions, frames);
+    expect(groups[0].map((frame) => frame.id)).toEqual(['f1', 'f1b']);
+    expect(groups[1].map((frame) => frame.id)).toEqual(['f2']);
+    expect(groups[2]).toEqual([]);
+  });
+
+  test('falls back to order when a rebuild decorates the title in a way we cannot parse', () => {
+    const frames = [
+      selectFrame('f1', 'Some unknown header'),
+      selectFrame('f2', 'Another unknown header'),
+      selectFrame('f3', 'A third unknown header'),
+    ];
+    const groups = groupAskFrames(questions, frames);
+    expect(groups.map((group) => group.map((frame) => frame.id))).toEqual([['f1'], ['f2'], ['f3']]);
+  });
+
+  test('keeps repeated multi-select dialogs on the question being answered', () => {
+    const frames = [
+      selectFrame('f1', '(1 selected) Which language should we use for this test? (1/3)'),
+      selectFrame('f2', '(1 selected) Which language should we use for this test? (1/3)'),
+      selectFrame('f3', 'What answer style do you prefer for testing? (2/3)'),
+    ];
+    const groups = groupAskFrames(questions, frames);
+    expect(groups[0].map((frame) => frame.id)).toEqual(['f1', 'f2']);
+    expect(groups[1].map((frame) => frame.id)).toEqual(['f3']);
+  });
+});
+
+describe('parseAskResult', () => {
+  const questions = parseAskQuestions(askTool(THREE_QUESTIONS));
+
+  test('reads every recorded answer from details.results', () => {
+    const answers = parseAskResult(askTool(THREE_QUESTIONS, {
+      details: {
+        results: [
+          { id: 'language', question: 'Which language?', selectedOptions: ['Python'] },
+          { id: 'style', question: 'Style?', selectedOptions: [], customInput: 'Dadadada' },
+          { id: 'confirm', question: 'Correct?', selectedOptions: ['Yes'], timedOut: true },
+        ],
+      },
+    }), questions);
+
+    expect(answers[0]).toEqual({ selectedOptions: ['Python'], customInput: undefined, timedOut: false });
+    expect(answers[1]?.customInput).toBe('Dadadada');
+    expect(answers[2]?.timedOut).toBe(true);
+  });
+
+  test('reads the flat shape omp returns for a single-question ask', () => {
+    const single = parseAskQuestions(askTool({ questions: [THREE_QUESTIONS.questions[0]] }));
+    const answers = parseAskResult(askTool({}, { details: { selectedOptions: ['Go'], multi: false } }), single);
+    expect(answers[0]?.selectedOptions).toEqual(['Go']);
+  });
+
+  test('leaves every question unanswered while the ask is still running', () => {
+    expect(parseAskResult(askTool(THREE_QUESTIONS), questions)).toEqual([null, null, null]);
+  });
+
+  test('falls back to the rendered text when details never reached the client', () => {
+    const output = 'User answers:\nlanguage: Python\nstyle: Balanced\nconfirm: Yes';
+    const answers = parseAskResult(askTool(THREE_QUESTIONS, { output }), questions);
+    expect(answers.map((answer) => answer?.selectedOptions)).toEqual([['Python'], ['Balanced'], ['Yes']]);
+  });
+
+  test('reads a typed custom answer out of the rendered text', () => {
+    const output = 'User answers:\nlanguage: Python\nstyle: "Dadadada"\nconfirm: Yes';
+    const answers = parseAskResult(askTool(THREE_QUESTIONS, { output }), questions);
+    expect(answers[1]).toEqual({ selectedOptions: [], customInput: 'Dadadada' });
+  });
+
+  test('reads the single-question result shapes', () => {
+    const single = parseAskQuestions(askTool({ questions: [THREE_QUESTIONS.questions[0]] }));
+    expect(parseAskResult(askTool({}, { output: 'User selected: Python' }), single)[0]?.selectedOptions).toEqual(['Python']);
+    expect(parseAskResult(askTool({}, { output: 'User provided custom input: Dadadada' }), single)[0]?.customInput)
+      .toBe('Dadadada');
+  });
+
+  test('never reads a failure message as an answer', () => {
+    const failed = askTool(THREE_QUESTIONS, {
+      output: 'Ask tool was cancelled by the user',
+      status: 'error' as const,
+    });
+    expect(parseAskResult(failed, questions)).toEqual([null, null, null]);
+  });
+});

package/src/shared/lib/chat/ask-questions.ts

@@ -0,0 +1,264 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Pure helpers for omp's `ask` tool: read its `questions` payload, pair the
+ * per-question dialogs omp raises for them back to the question they belong to,
+ * and read the recorded answers out of the tool result.
+ *
+ * The pairing is load-bearing, and the reason is worth stating: omp's RPC UI
+ * context implements `select`/`confirm`/`input`/`editor` but NOT the rich
+ * `askDialog` primitive the TUI uses. `AskTool` therefore falls back to its
+ * per-question loop, and over RPC a multi-question ask reaches the chamber as
+ * ONE blocking `select` frame per question, in order — never as one payload. The
+ * frame carries the question as its `title` (plus a ` (2/3)` progress suffix and
+ * a `(2 selected) ` prefix for multi-select questions), which is what lets the
+ * inline card put each frame back on the question it asked.
+ */
+
+import type { ToolCallData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+
+export interface AskOption {
+  label: string;
+  description?: string;
+  preview?: string;
+}
+
+export interface AskQuestion {
+  id?: string;
+  /** Short chip omp shows above the question ("Authentication"). */
+  header?: string;
+  question: string;
+  options: AskOption[];
+  multi: boolean;
+  /** Index of the option omp marks ` (Recommended)`. */
+  recommended?: number;
+}
+
+export interface AskAnswer {
+  selectedOptions: string[];
+  customInput?: string;
+  /** omp auto-selected the answer after `ask.timeout` elapsed. */
+  timedOut?: boolean;
+}
+
+/** The free-text escape hatch omp appends to every question's option list. */
+const OTHER_OPTION = /^other\b/i;
+/** Trailing ` (2/3)` omp adds while looping over several questions. */
+const PROGRESS_SUFFIX = /\s+\(\d+\s*\/\s*\d+\)$/;
+/** Leading `(2 selected) ` omp prepends to a multi-select question's title. */
+const SELECTED_COUNT_PREFIX = /^\(\d+\s+selected\)\s*/;
+
+/** True for the literal "Other (type your own)" row, which is a prompt to type
+ *  an answer rather than an answer itself. */
+export function isOtherOption(label: string): boolean {
+  return OTHER_OPTION.test(label.trim());
+}
+
+/** Normalized question text, with the decorations omp adds to a live dialog
+ *  title stripped, so a frame can be matched against the question that raised it. */
+export function normalizeAskText(value: string): string {
+  return value
+    .replace(SELECTED_COUNT_PREFIX, '')
+    .replace(PROGRESS_SUFFIX, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function readOption(raw: unknown): AskOption | null {
+  if (typeof raw === 'string') {
+    const label = raw.trim();
+    return label ? { label } : null;
+  }
+  if (!raw || typeof raw !== 'object') return null;
+  const record = raw as Record<string, unknown>;
+  const label = typeof record.label === 'string' ? record.label.trim() : '';
+  if (!label) return null;
+  return {
+    label,
+    description: typeof record.description === 'string' ? record.description : undefined,
+    preview: typeof record.preview === 'string' ? record.preview : undefined,
+  };
+}
+
+/** True for a tool call that is omp's `ask` tool. */
+export function isAskToolCall(tool: ToolCallData): boolean {
+  const name = typeof tool.name === 'string' && tool.name ? tool.name : tool.type;
+  return name === 'ask' || tool.title === 'ask';
+}
+
+/**
+ * The `questions` array from an `ask` tool call's arguments. Empty when the tool
+ * is not an ask call or its arguments were truncated — callers fall back to the
+ * raw arguments/output rendering in that case.
+ */
+export function parseAskQuestions(tool: ToolCallData): AskQuestion[] {
+  const input = tool.input;
+  const record = typeof input === 'object' && input !== null ? (input as Record<string, unknown>) : null;
+  const raw = record && Array.isArray(record.questions) ? record.questions : [];
+  const questions: AskQuestion[] = [];
+
+  for (const entry of raw) {
+    if (!entry || typeof entry !== 'object') continue;
+    const question = entry as Record<string, unknown>;
+    const text = typeof question.question === 'string' ? question.question.trim() : '';
+    if (!text) continue;
+    questions.push({
+      id: typeof question.id === 'string' ? question.id : undefined,
+      header: typeof question.header === 'string' && question.header.trim() ? question.header.trim() : undefined,
+      question: text,
+      options: Array.isArray(question.options)
+        ? question.options.map(readOption).filter((option): option is AskOption => option !== null)
+        : [],
+      multi: question.multi === true,
+      recommended: typeof question.recommended === 'number' ? question.recommended : undefined,
+    });
+  }
+
+  return questions;
+}
+
+function readAnswer(row: Record<string, unknown>): AskAnswer {
+  return {
+    selectedOptions: Array.isArray(row.selectedOptions)
+      ? row.selectedOptions.filter((value): value is string => typeof value === 'string')
+      : [],
+    customInput: typeof row.customInput === 'string' && row.customInput ? row.customInput : undefined,
+    timedOut: row.timedOut === true,
+  };
+}
+
+/** One `<id>: <answer>` line of a multi-question result. */
+const ANSWER_LINE = /^([\w.-]+):\s*(.+)$/;
+/** The single-question result's two prose shapes. */
+const SELECTED_LINE = /^User selected:\s*(.+)$/m;
+const CUSTOM_LINE = /^User provided custom input:\s*([\s\S]+)$/m;
+
+/** `value` as omp renders it: a quoted string is typed input, a bare one is a
+ *  picked label (comma-joined when the question allows several). */
+function toAnswer(value: string, multi: boolean): AskAnswer {
+  const text = value.trim();
+  if (/^"[\s\S]*"$/.test(text)) return { selectedOptions: [], customInput: text.slice(1, -1) };
+  const labels = multi && text.includes(', ') ? text.split(', ') : [text];
+  return { selectedOptions: labels.map((label) => label.trim()).filter(Boolean) };
+}
+
+/**
+ * Answers recovered from the tool's rendered text, used when `details` never
+ * reached this client. `details` is the richer source, but it is dropped by the
+ * live `tool_execution_end` frame on some omp builds; the text is the one part
+ * of a settled result every path carries, and it names each answer by question
+ * id (`language: Python`) or as a single sentence for a one-question ask.
+ */
+function parseAskOutputAnswers(output: string, questions: AskQuestion[]): (AskAnswer | null)[] {
+  const answers = questions.map((): AskAnswer | null => null);
+  const text = output.trim();
+  if (!text) return answers;
+
+  const byId = new Map<string, AskAnswer>();
+  for (const line of text.split('\n')) {
+    const match = ANSWER_LINE.exec(line.trim());
+    if (match) byId.set(match[1], toAnswer(match[2], questions.some((question) => question.multi)));
+  }
+  if (byId.size > 0) {
+    const ordered = [...byId.values()];
+    for (let index = 0; index < questions.length; index += 1) {
+      // The question id is the key omp prints; position is what is left when a
+      // payload carries no ids at all (omp requires them, so this is defensive).
+      const id = questions[index].id;
+      answers[index] = (id ? byId.get(id) : undefined) ?? ordered[index] ?? null;
+    }
+    return answers;
+  }
+
+  const selected = SELECTED_LINE.exec(text);
+  if (selected) {
+    answers[0] = toAnswer(selected[1], questions[0].multi);
+    return answers;
+  }
+  const custom = CUSTOM_LINE.exec(text);
+  if (custom) {
+    answers[0] = { selectedOptions: [], customInput: custom[1].trim() };
+    return answers;
+  }
+  if (questions.length === 1 && !text.includes('\n')) {
+    answers[0] = { selectedOptions: [text] };
+  }
+  return answers;
+}
+
+/**
+ * Answers recorded in an `ask` tool result, positionally aligned with
+ * `questions`. omp returns `details.results[]` for a multi-question ask and the
+ * bare answer fields for a single-question one; the rendered text backs both up.
+ */
+export function parseAskResult(tool: ToolCallData, questions: AskQuestion[]): (AskAnswer | null)[] {
+  const answers = questions.map((): AskAnswer | null => null);
+  if (questions.length === 0) return answers;
+
+  const details = tool.details ?? {};
+  const results = Array.isArray(details.results) ? (details.results as Record<string, unknown>[]) : null;
+  if (results) {
+    for (let index = 0; index < answers.length; index += 1) {
+      const row = results[index];
+      if (row && typeof row === 'object') answers[index] = readAnswer(row);
+    }
+    return answers;
+  }
+
+  if (typeof details.selectedOptions !== 'undefined' || typeof details.customInput === 'string') {
+    answers[0] = readAnswer(details);
+    return answers;
+  }
+
+  // A failed/cancelled ask answers nothing; its text is the reason, which would
+  // otherwise read as an answer for whichever id its first sentence names.
+  if (tool.status === 'error' || tool.status === 'aborted' || tool.isError) return answers;
+
+  return parseAskOutputAnswers(typeof tool.output === 'string' ? tool.output : '', questions);
+}
+
+/**
+ * Bucket the ask's dialogs by question index.
+ *
+ * Assignment follows omp's own order rather than pure title matching: a frame
+ * whose title names a question moves the cursor onto it, and any other frame
+ * (the `editor`/`input` dialog omp opens after "Other (type your own)") belongs
+ * to whichever question was last named. A title that names an EARLIER question
+ * is ignored — omp walks the questions forward and never re-asks one, so a
+ * repeat can only be a multi-select re-render of the question already in hand.
+ */
+export function groupAskFrames(
+  questions: AskQuestion[],
+  frames: ExtensionUiDialogRequest[],
+): ExtensionUiDialogRequest[][] {
+  const groups = questions.map((): ExtensionUiDialogRequest[] => []);
+  if (questions.length === 0) return groups;
+  const titles = questions.map((question) => normalizeAskText(question.question));
+
+  let cursor = 0;
+  for (const frame of frames) {
+    const title = typeof frame.title === 'string' ? normalizeAskText(frame.title) : '';
+    const index = titles.indexOf(title);
+    if (index > cursor) {
+      cursor = index;
+    } else if (
+      index === -1 &&
+      frame.method === 'select' &&
+      groups[cursor].some((held) => held.method === 'select') &&
+      cursor + 1 < groups.length
+    ) {
+      // Title matching is the authority, but a question is asked by exactly one
+      // `select` — a second one that matches nothing is the NEXT question with
+      // decorations this build does not know about, not a repeat.
+      cursor += 1;
+    }
+    groups[cursor].push(frame);
+  }
+
+  return groups;
+}

package/src/shared/lib/chat/omp/agent-events.test.ts

@@ -25,10 +25,14 @@ const ABORTED_TURN = {
 function makeDeps() {
   const ended: ChatMessageData[] = [];
   const activity: string[] = [];
+  const commandOutputs: string[] = [];
+  let settledCount = 0;
   let state: OmpAgentState = { isGenerating: false, connected: true, error: null };
   const callbacks: OmpAgentCallbacks = {
     onMessageEnd: (msg) => ended.push(msg),
     onActivity: (verb) => activity.push(verb),
+    onPromptSettled: () => { settledCount += 1; },
+    onCommandOutput: (text) => commandOutputs.push(text),
   };
   const deps: OmpAgentFoldDeps = {
     sessionId: 's1',
@@ -43,7 +47,7 @@ function makeDeps() {
     currentThinkingLevelRef: { current: undefined },
     fileMutatingCallsRef: { current: new Set<string>() },
   };
-  return { deps, ended, activity };
+  return { deps, ended, activity, commandOutputs, settled: () => settledCount, state: () => state };
 }
 
 describe('toChatMessage error derivation', () => {
@@ -60,6 +64,38 @@ describe('toChatMessage error derivation', () => {
   });
 });
 
+describe('foldAgentEvent prompt_result (builtin slash commands)', () => {
+  test('agentInvoked:false settles generating state and fires onPromptSettled', () => {
+    const { deps, state, settled } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    expect(state().isGenerating).toBe(true);
+    foldAgentEvent({ type: 'prompt_result', agentInvoked: false }, deps);
+    expect(state().isGenerating).toBe(false);
+    expect(settled()).toBe(1);
+  });
+
+  test('prompt_result with agentInvoked:true does not settle (a run follows)', () => {
+    const { deps, settled } = makeDeps();
+    foldAgentEvent({ type: 'prompt_result', agentInvoked: true }, deps);
+    expect(settled()).toBe(0);
+  });
+});
+
+describe('foldAgentEvent command_output (builtin slash output)', () => {
+  test('forwards trimmed text to onCommandOutput', () => {
+    const { deps, commandOutputs } = makeDeps();
+    foldAgentEvent({ type: 'command_output', text: 'Usage\nInput tokens: 0\n' }, deps);
+    expect(commandOutputs).toEqual(['Usage\nInput tokens: 0']);
+  });
+
+  test('drops empty output frames', () => {
+    const { deps, commandOutputs } = makeDeps();
+    foldAgentEvent({ type: 'command_output', text: '   ' }, deps);
+    foldAgentEvent({ type: 'command_output' }, deps);
+    expect(commandOutputs).toEqual([]);
+  });
+});
+
 describe('foldAgentEvent activity phrases', () => {
   test('names the tool being executed, not a generic reasoning verb', () => {
     const { deps, activity } = makeDeps();