@kabmo-labs/kabmo 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,307 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import type { ChatMessageData, OmpAgentCallbacks, OmpAgentState } from '@/shared/types';
+import { foldAgentEvent, type OmpAgentFoldDeps } from '@/shared/lib/chat/omp/agent-events';
+import { toChatMessage } from '@/shared/lib/omp/session/mapper';
+
+/** Real shape omp writes on a user abort: empty content plus flat
+ *  stopReason/errorMessage/errorId fields — there is no nested `error`. */
+const ABORTED_TURN = {
+  role: 'assistant',
+  content: [{ type: 'text', text: '' }],
+  provider: 'openai',
+  model: 'gpt-5',
+  stopReason: 'aborted',
+  errorMessage: 'Interrupted by user',
+  errorId: 67112960,
+  timestamp: 1757943900000,
+};
+
+function makeDeps() {
+  const ended: ChatMessageData[] = [];
+  const updates: ChatMessageData[] = [];
+  const activity: string[] = [];
+  const commandOutputs: string[] = [];
+  let settledCount = 0;
+  let runEnds = 0;
+  let state: OmpAgentState = { isGenerating: false, connected: true, error: null };
+  const callbacks: OmpAgentCallbacks = {
+    onMessageEnd: (msg) => ended.push(msg),
+    onMessageUpdate: (msg) => updates.push(msg),
+    onActivity: (verb) => activity.push(verb),
+    onPromptSettled: () => { settledCount += 1; },
+    onCommandOutput: (text) => commandOutputs.push(text),
+    onAgentEnd: () => { runEnds += 1; },
+  };
+  const deps: OmpAgentFoldDeps = {
+    sessionId: 's1',
+    setState: (update) => {
+      state = typeof update === 'function' ? update(state) : update;
+    },
+    callbacksRef: { current: callbacks },
+    toolResultsRef: { current: new Map<string, { output: string }>() },
+    lastToolMessageRef: { current: null },
+    activityRef: { current: '' },
+    providerRetryVerbRef: { current: null },
+    currentThinkingLevelRef: { current: undefined },
+  };
+  return { deps, ended, updates, activity, commandOutputs, settled: () => settledCount, runEnds: () => runEnds, state: () => state };
+}
+
+describe('toChatMessage error derivation', () => {
+  test('keeps an aborted turn that carries no text', () => {
+    const msg = toChatMessage(ABORTED_TURN, false);
+    expect(msg).not.toBeNull();
+    expect(msg?.error?.message).toBe('Interrupted by user');
+    expect(msg?.error?.stopReason).toBe('aborted');
+  });
+
+  test('leaves a normally finished turn without an error', () => {
+    const msg = toChatMessage({ ...ABORTED_TURN, stopReason: 'end_turn', errorMessage: undefined }, false);
+    expect(msg?.error).toBeUndefined();
+  });
+});
+
+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();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    foldAgentEvent({
+      type: 'tool_execution_start',
+      toolCallId: 'c1',
+      toolName: 'edit',
+      args: { path: 'app/lib/chat/order.ts', old_string: 'a', new_string: 'b' },
+    }, deps);
+    expect(activity).toEqual(['Thinking', 'Editing app/lib/chat/order.ts']);
+  });
+
+  test('resolves an xd:// device write to the device action', () => {
+    const { deps, activity } = makeDeps();
+    foldAgentEvent({
+      type: 'tool_execution_start',
+      toolCallId: 'c2',
+      toolName: 'write',
+      args: { path: 'xd://ast_edit', content: JSON.stringify({ pat: 'x', out: 'y', paths: ['src/**/*.ts'] }) },
+    }, deps);
+    expect(activity).toEqual(['Rewriting AST src/**/*.ts']);
+  });
+
+  test('follows the assistant phase before any tool starts', () => {
+    const { deps, activity } = makeDeps();
+    foldAgentEvent({ type: 'message_update', message: { role: 'assistant', content: [] }, assistantMessageEvent: { type: 'thinking_delta', delta: 'x' } }, deps);
+    foldAgentEvent({ type: 'message_update', message: { role: 'assistant', content: [] }, assistantMessageEvent: { type: 'text_delta', delta: 'x' } }, deps);
+    foldAgentEvent({
+      type: 'message_update',
+      message: { role: 'assistant', content: [] },
+      assistantMessageEvent: { type: 'toolcall_end', toolCall: { id: 'c3', name: 'bash', arguments: { command: 'bun test' } } },
+    }, deps);
+    expect(activity).toEqual(['Thinking', 'Writing response', 'Running bun test']);
+  });
+
+  test('names the tool as soon as its call starts streaming, with no preparing state', () => {
+    const { deps, activity } = makeDeps();
+    // omp puts the streaming call at partial.content[contentIndex] while the
+    // event's own `toolCall` field only lands on toolcall_end.
+    const streaming = (name: string) => ({
+      type: 'message_update',
+      message: { role: 'assistant', content: [] },
+      assistantMessageEvent: { type: 'toolcall_start', contentIndex: 0, partial: { content: [{ type: 'toolCall', name, arguments: {} }] } },
+    });
+    foldAgentEvent(streaming('write'), deps);
+    foldAgentEvent({ ...streaming('edit'), assistantMessageEvent: { type: 'toolcall_delta', contentIndex: 0, partial: { content: [{ type: 'toolCall', name: 'edit', arguments: {} }] } } }, deps);
+    expect(activity).toEqual(['Writing', 'Editing']);
+  });
+
+  test('reports Thinking, not a results phase, once a tool returns', () => {
+    const { deps, activity } = makeDeps();
+    foldAgentEvent({ type: 'tool_execution_start', toolCallId: 'c5', toolName: 'bash', args: { command: 'ls' } }, deps);
+    foldAgentEvent({ type: 'tool_execution_end', toolCallId: 'c5', result: { content: [{ type: 'text', text: 'ok' }] } }, deps);
+    expect(activity).toEqual(['Running ls', 'Thinking']);
+  });
+
+  test('does not re-publish the same phrase for per-token frames', () => {
+    const { deps, activity } = makeDeps();
+    for (let i = 0; i < 5; i++) {
+      foldAgentEvent({ type: 'message_update', message: { role: 'assistant', content: [] }, assistantMessageEvent: { type: 'thinking_delta', delta: 'x' } }, deps);
+    }
+    expect(activity).toEqual(['Thinking']);
+  });
+
+  test('keeps a complete phrase when a tool call carries no arguments', () => {
+    const { deps, activity } = makeDeps();
+    // A model can emit `arguments: {}` (seen with deepseek-v4-flash): the tool
+    // name alone must still read as an activity, never a dangling verb.
+    foldAgentEvent({ type: 'tool_execution_start', toolCallId: 'c4', toolName: 'bash', args: {} }, deps);
+    expect(activity).toEqual(['Running']);
+  });
+});
+
+describe('foldAgentEvent tool images', () => {
+  const IMAGE_MSG = {
+    role: 'assistant',
+    id: 'm1',
+    content: [
+      { type: 'toolCall', id: 'c1', name: 'read', arguments: { path: '/tmp/shiki96.png' } },
+    ],
+  };
+
+  test('a read result pairs its image onto the tool call', () => {
+    // A `read` of an image answers with the picture itself, and the panel has
+    // no other way to reach it: the PATH is routinely outside the browse scope
+    // (`/tmp/...`), so `/api/fs/raw` refuses it and the result's own bytes are
+    // the only copy the timeline can paint. The pairing re-emits the message,
+    // so the assertion reads the update channel the timeline subscribes to.
+    const { deps, updates } = makeDeps();
+    foldAgentEvent({ type: 'message_end', message: IMAGE_MSG }, deps);
+    foldAgentEvent({
+      type: 'tool_execution_end',
+      toolCallId: 'c1',
+      result: {
+        content: [
+          { type: 'text', text: 'Read image file [image/jpeg]' },
+          { type: 'image', data: `blob:sha256:${'a'.repeat(64)}`, mimeType: 'image/jpeg' },
+        ],
+      },
+    }, deps);
+
+    expect(updates.at(-1)?.toolCalls?.[0]?.images).toEqual([
+      { mimeType: 'image/jpeg', blobRef: `blob:sha256:${'a'.repeat(64)}` },
+    ]);
+  });
+
+  test('a result with no image leaves the field unset', () => {
+    // The fallback (re-read the path) must only fire for a call whose result
+    // genuinely carried no picture — a text read is not an image read.
+    const { deps, updates } = makeDeps();
+    foldAgentEvent({ type: 'message_end', message: IMAGE_MSG }, deps);
+    foldAgentEvent({ type: 'tool_execution_end', toolCallId: 'c1', result: { content: [{ type: 'text', text: '1: hello' }] } }, deps);
+
+    expect(updates.at(-1)?.toolCalls?.[0]?.images).toBeUndefined();
+  });
+});
+
+describe('foldAgentEvent agent_end', () => {
+  test('materializes an aborted turn that never arrived as message_end', () => {
+    const { deps, ended } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    foldAgentEvent({ type: 'agent_end', messages: [ABORTED_TURN] }, deps);
+    expect(ended).toHaveLength(1);
+    expect(ended[0]?.error?.message).toBe('Interrupted by user');
+    expect(ended[0]?.error?.stopReason).toBe('aborted');
+  });
+
+  test('ignores a turn that finished normally', () => {
+    const { deps, ended } = makeDeps();
+    foldAgentEvent({ type: 'agent_end', messages: [{ ...ABORTED_TURN, stopReason: 'end_turn' }] }, deps);
+    expect(ended).toHaveLength(0);
+  });
+
+  test('a non-terminal agent_end keeps the run generating and does not fire onAgentEnd', () => {
+    // omp's shape when the turn yields with work still alive — a detached
+    // subagent, a compaction, a background job. Measured on omp 18.3.2: with an
+    // async subagent, this frame lands ~14s BEFORE the subagent finishes, and
+    // treating it as the run end blanked the generating indicator for the whole
+    // stretch the roster was still showing a live child.
+    const { deps, state, runEnds } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    expect(state().isGenerating).toBe(true);
+
+    foldAgentEvent({ type: 'agent_end', isTerminal: false, messages: [] }, deps);
+    expect(state().isGenerating).toBe(true);
+    expect(runEnds()).toBe(0);
+
+    // The continuation ends the run for real; only now may the UI settle.
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    foldAgentEvent({ type: 'agent_end', isTerminal: true, messages: [] }, deps);
+    expect(state().isGenerating).toBe(false);
+    expect(runEnds()).toBe(1);
+  });
+
+  test('an agent_end with no isTerminal field is treated as terminal', () => {
+    // The field is optional: a frame that omits it is a normal run end.
+    const { deps, state, runEnds } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    foldAgentEvent({ type: 'agent_end', messages: [] }, deps);
+    expect(state().isGenerating).toBe(false);
+    expect(runEnds()).toBe(1);
+  });
+
+  test('an attempt re-entering the loop does not wipe the retry phrase', () => {
+    // Every retry of a provider-error saga opens a fresh `agent_start`, and
+    // `onAgentStart` publishes "Thinking" itself — so the fold's ref-aware
+    // publish has to come after the callback, or the phrase the user needs is
+    // replaced a frame after it appears (measured on a real quota wall).
+    const { deps, activity } = makeDeps();
+    deps.providerRetryVerbRef.current = 'Retrying after a provider error 2/3 · next in 4s';
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    expect(activity.at(-1)).toBe('Retrying after a provider error 2/3 · next in 4s');
+  });
+
+  test('a terminal run end closes the retry saga', () => {
+    const { deps, activity } = makeDeps();
+    deps.providerRetryVerbRef.current = 'Retrying after a provider error 3/3 · next in 4s';
+    foldAgentEvent({ type: 'agent_end', isTerminal: true, messages: [] }, deps);
+    expect(deps.providerRetryVerbRef.current).toBeNull();
+    expect(activity.at(-1)).toBe('Thinking');
+  });
+});
+
+describe('foldAgentEvent tool_execution_update (running tool output)', () => {
+  /** One snapshot frame, in the shape omp actually sends. */
+  const update = (text: string) => ({
+    type: 'tool_execution_update',
+    toolCallId: 'call-1',
+    toolName: 'bash',
+    partialResult: { content: [{ type: 'text', text }] },
+  });
+
+  test('a partial result REPLACES the stored output instead of appending', () => {
+    // omp's `partialResult` is the tool's output so far, not the fragment since
+    // the previous frame. Measured on 18.3.0 and 18.8.3: a bash loop echoing
+    // one line per second reports "L1", then "L1\nL2", then "L1\nL2\nL3".
+    // Appending those snapshots produced "L1\nL1\nL2\nL1\nL2\nL3" on a card
+    // that was still running.
+    const { deps } = makeDeps();
+    foldAgentEvent(update('L1\n') as never, deps);
+    foldAgentEvent(update('L1\nL2\n') as never, deps);
+    foldAgentEvent(update('L1\nL2\nL3\n') as never, deps);
+    expect(deps.toolResultsRef.current?.get('call-1')?.output).toBe('L1\nL2\nL3\n');
+  });
+});

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

@@ -0,0 +1,302 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Folds one live agent event frame into Kabmo state. Transport-agnostic: the
+ * WebSocket and SSE clients both hand every decoded frame to `foldAgentEvent`,
+ * so both transports produce byte-identical timeline behavior.
+ *
+ * Split out of useOmpAgentStream so the hook owns only connection lifecycle
+ * (open, reconnect, teardown) and each file stays under the repo's per-file
+ * size ceiling.
+ */
+
+import type { IncomingExtensionUiRequest, OmpAgentEvent } from '@/shared/types';
+import { extractTextFromContent, toChatMessage } from '@/shared/lib/omp/session/mapper';
+import { normalizeNoticeText } from '@/shared/lib/chat/notice-text';
+import { parseModeMarker } from '@/shared/lib/omp/mode/markers';
+import { emitKabmoModeSignal } from '@/shared/lib/omp/mode/client-signal';
+import { KABMO_GOAL_EVALUATING_MARKER } from '@/shared/lib/omp/mode/types';
+import { materializeTerminalMessages } from '@/shared/lib/chat/omp/terminal-messages';
+import { invalidateComposerCache } from '@/shared/lib/chat/composer/client';
+import { setActivity, toolHost, type OmpAgentFoldDeps } from '@/shared/lib/chat/omp/fold-deps';
+import { normalizeThinkingLevel } from '@/shared/lib/models/thinking-levels';
+import { endRetrySaga, foldAutoRetry } from '@/shared/lib/chat/timeline/provider-retry';
+import { foldTransportFrame } from '@/shared/lib/chat/omp/transport-frames';
+import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
+import { describeAssistantPhase } from '@/shared/lib/chat/timeline/tool-verbs';
+import { publishSubagentFrame } from '@/shared/lib/chat/omp/subagent-frames';
+import {
+  pairToolOutputs,
+  recordToolResult,
+  refreshToolMessage,
+} from '@/shared/lib/chat/omp/tool-results';
+import { foldToolEnd, foldToolStart, foldToolUpdate } from '@/shared/lib/chat/omp/tool-frames';
+
+// Re-exported so stream.ts and the timeline hook keep their existing import
+// site; the implementation lives in tool-results.ts.
+export type { ToolResultRecord } from '@/shared/lib/chat/omp/tool-results';
+export type { OmpAgentFoldDeps } from '@/shared/lib/chat/omp/fold-deps';
+
+export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): void {
+  const callbacks = deps.callbacksRef.current;
+  switch (data.type) {
+    case 'agent_start':
+      deps.setState((prev) => ({ ...prev, isGenerating: true, error: null }));
+      deps.toolResultsRef.current?.clear();
+      deps.lastToolMessageRef.current = null;
+      // A fresh run restarts level tracking; the first turn relies on the
+      // session-level value until omp emits thinking_level_changed (or not).
+      deps.currentThinkingLevelRef.current = undefined;
+      // The callback publishes its own "Thinking" phrase, so the fold's one has
+      // to come AFTER it: every retry of a saga re-enters here with an
+      // `agent_start`, and a direct write would otherwise wipe the retry phrase
+      // `setActivity` exists to keep (see `providerRetryVerbRef`).
+      callbacks?.onAgentStart?.();
+      setActivity(PHASE_VERBS.thinking, deps);
+      break;
+
+    case 'turn_start':
+      setActivity(PHASE_VERBS.thinking, deps);
+      callbacks?.onTurnStart?.();
+      break;
+
+    case 'message_start':
+    case 'message_update': {
+      const msg = data.message as Record<string, unknown> | undefined;
+      if (!msg) break;
+      if (msg.role === 'toolResult') {
+        recordToolResult(msg, deps);
+        setActivity(PHASE_VERBS.thinking, deps);
+        break;
+      }
+      // Assistant phases (thinking / prose / tool-call assembly) name the
+      // action directly — a tool that never starts still shows its phrase.
+      setActivity(describeAssistantPhase(data.assistantMessageEvent), deps);
+      // The first message frame of a turn is another proof the run is live —
+      // re-signal so the sidebar can restore a lost `stream` status row.
+      // message_update frames arrive per delta and must stay silent here.
+      if (data.type === 'message_start') callbacks?.onTurnStart?.();
+      // Steering (abort_and_prompt) and follow-up deliveries create no
+      // optimistic bubble — the user turn only exists on the stream. Convert
+      // it here so the bubble renders live instead of after a JSONL reload.
+      // The callbacks append user rows (never overwrite the streaming AI
+      // placeholder) and dedup by omp message id.
+      const converted = toChatMessage(msg);
+      if (converted) {
+        if (converted.role !== 'user' && deps.currentThinkingLevelRef.current) {
+          converted.thinkingLevel = deps.currentThinkingLevelRef.current;
+        }
+        callbacks?.onMessageUpdate?.(converted);
+      }
+      break;
+    }
+
+    case 'message_end': {
+      const completed = data.message as Record<string, unknown> | undefined;
+      if (!completed) break;
+      if (completed.role === 'toolResult') {
+        recordToolResult(completed, toolHost(deps));
+        // Re-pair the card now. omp sends this frame AFTER `tool_execution_end`,
+        // but the two are independent, and a result that arrived first (or a
+        // build whose `_end` frame carried no details) must still reach the row
+        // that is on screen.
+        refreshToolMessage(typeof completed.toolCallId === 'string' ? completed.toolCallId : undefined, toolHost(deps));
+        break;
+      }
+      if (completed.role === 'custom') break;
+      if (completed.role === 'user') {
+        const delivered = extractTextFromContent(completed.content);
+        if (delivered) callbacks?.onQueuedMessageDelivered?.(delivered);
+        break;
+      }
+      const converted = toChatMessage(completed, false);
+      if (!converted) break;
+      if (converted.role !== 'user' && deps.currentThinkingLevelRef.current) {
+        converted.thinkingLevel = deps.currentThinkingLevelRef.current;
+      }
+      const paired = pairToolOutputs(converted, deps);
+      if (paired.toolCalls?.length) deps.lastToolMessageRef.current = paired;
+      callbacks?.onMessageEnd?.(paired);
+      break;
+    }
+
+    case 'tool_execution_start':
+      foldToolStart(data as Record<string, unknown>, deps);
+      break;
+
+    case 'tool_execution_update':
+      foldToolUpdate(data as Record<string, unknown>, deps);
+      break;
+
+    case 'tool_execution_end':
+      foldToolEnd(data as Record<string, unknown>, deps);
+      break;
+
+    case 'agent_end': {
+      // A NON-TERMINAL `agent_end` is not the end of the run: omp emits it when
+      // the turn yields but work is still alive — a detached subagent, a
+      // compaction, a background job, or a stop-time reminder — and a later
+      // `agent_start` opens the continuation. Measured on omp 18.3.2: with an
+      // async subagent, `agent_end isTerminal=false` arrives ~13s BEFORE the
+      // subagent's terminal frame, and clearing the generating state there
+      // blanked the indicator for the whole stretch the roster was still
+      // showing a live child. The server's own fold gates on the same field
+      // (frame-fold.ts), so the two ends now agree.
+      if (data.isTerminal === false) break;
+      // A retry saga cannot survive the run: a terminal end may arrive with no
+      // `auto_retry_end` in front of it.
+      endRetrySaga(deps);
+      deps.setState((prev) => ({ ...prev, isGenerating: false }));
+      deps.activityRef.current = '';
+      const terminal = materializeTerminalMessages(data, deps, callbacks ?? undefined);
+      callbacks?.onAgentEnd?.({
+        errorMessage: terminal.errorMessage
+          ?? (typeof data.errorMessage === 'string' ? data.errorMessage : undefined),
+        message: typeof data.message === 'string' ? data.message : undefined,
+      });
+      break;
+    }
+
+    case 'prompt_error': {
+      const errorMessage = typeof data.errorMessage === 'string' ? data.errorMessage : 'Prompt failed';
+      deps.setState((prev) => ({ ...prev, isGenerating: false, error: errorMessage }));
+      deps.activityRef.current = '';
+      callbacks?.onPromptError?.(errorMessage);
+      break;
+    }
+
+    // omp's prompt ack ran a built-in slash command instead of an agent turn
+    // (`agentInvoked:false`, mirrored server-side as this frame): there will be
+    // no agent_start/agent_end pair. Clear the optimistic generating state —
+    // the callbacks drop the AI placeholder and keep the user's message row.
+    case 'prompt_result': {
+      if (data.agentInvoked === false) {
+        deps.setState((prev) => ({ ...prev, isGenerating: false }));
+        deps.activityRef.current = '';
+        callbacks?.onPromptSettled?.();
+      }
+      break;
+    }
+
+    // omp replays a transient provider error by itself — rate limit, outage,
+    // quota wall — and keeps the RUN open across the attempts: each retry
+    // announces itself here and opens a fresh `agent_start`, with no `agent_end`
+    // in between. Without this the indicator stayed on the generic "Thinking…"
+    // for the whole stall, over a transcript whose last row was the failure.
+    // See `provider-retry.ts` for the phrase and the one-row-per-saga rule.
+    case 'auto_retry_start':
+    case 'auto_retry_end':
+      foldAutoRetry(data, deps);
+      break;
+
+    // Built-in slash command output (/usage, /compact result, …). Rendered as
+    // a notice row — see the callback type note: this frame is the ONLY copy.
+    // `normalizeNoticeText` strips the terminal formatting omp emits here; the
+    // reload path applies the same function so both agree.
+    case 'command_output': {
+      const text = typeof data.text === 'string' ? normalizeNoticeText(data.text) : '';
+      if (text) callbacks?.onCommandOutput?.(text);
+      break;
+    }
+
+    // omp renamed the session (auto-title generation, /rename, set_session_name).
+    // Nothing in the timeline changes, but the sidebar reads titles from the
+    // session file — and the rename is a 256-byte in-place slot write that the
+    // scan cache's mtime key cannot see — so this frame is the only push
+    // signal that the list is stale.
+    case 'session_info_update': {
+      const title = typeof data.title === 'string' ? data.title.trim() : '';
+      if (title) callbacks?.onSessionTitleChanged?.(title);
+      break;
+    }
+
+    case 'notice': {
+      callbacks?.onNotice?.(
+        typeof data.level === 'string' ? data.level : 'info',
+        typeof data.message === 'string' ? data.message : '',
+      );
+      break;
+    }
+
+    case 'extension_ui_request': {
+      // The Kabmo's mode extension reports every plan/goal transition through
+      // `ctx.ui.notify`, which omp frames as an `extension_ui_request` with
+      // `method: "notify"` — NOT a `notice` frame (verified against omp 18.4.4:
+      // `rpc-mode.ts`'s `notify` implementation emits exactly that).
+      //
+      // Those payloads are composer state, not conversation, so they are
+      // intercepted here rather than handed to the dialog path: the dialog
+      // renderer would paint a modal for a mode toggle. A marker whose payload
+      // does not parse is NOT intercepted — it falls through as an ordinary
+      // notify, so a version skew shows a readable line instead of silence.
+      //
+      // Delivered as a scoped window event (the shape the subagent frames use),
+      // because the consumer is the composer's mode hook: routing it through
+      // `callbacks` would thread a payload the timeline itself never reads
+      // through four components.
+      if ((data as { method?: unknown }).method === 'notify') {
+        const message = typeof data.message === 'string' ? data.message : '';
+        const marker = parseModeMarker(message);
+        if (marker) {
+          emitKabmoModeSignal(deps.sessionId, marker);
+          break;
+        }
+      }
+      callbacks?.onExtensionUiRequest?.(data as unknown as IncomingExtensionUiRequest);
+      break;
+    }
+
+    case 'goal_evaluating': {
+      // The Kabmo's auditor working on the turn that just ended. No model
+      // turn is streaming while it runs, so without this frame the composer
+      // would look idle during the seconds the check takes.
+      emitKabmoModeSignal(deps.sessionId, {
+        marker: KABMO_GOAL_EVALUATING_MARKER,
+        payload: { evaluating: data.evaluating === true },
+      });
+      break;
+    }
+
+    case 'subagent_lifecycle':
+    case 'subagent_progress':
+    case 'subagent_event': {
+      // Forward live subagent frames to the subagent views through the module
+      // bus. The frames already arrived over the `session:<id>` topic; this is
+      // the second hop to the surfaces that render one child.
+      const payload = data.payload;
+      if (payload === undefined || payload === null || typeof payload !== 'object') break;
+      publishSubagentFrame(data.type, { sessionId: deps.sessionId, payload });
+      break;
+    }
+
+    case 'model_changed':
+      callbacks?.onModelChanged?.();
+      break;
+
+    // The live `thinking_level_changed` frame carries the new session level
+    // (e.g. { thinkingLevel: "high", configured, resolved }); null → "off".
+    // Record it so subsequent assistant turns are stamped with the level that
+    // actually served them — mirrors the JSONL `thinking_level_change` walk.
+    case 'thinking_level_changed':
+      deps.currentThinkingLevelRef.current = normalizeThinkingLevel(data.thinkingLevel);
+      break;
+
+    // omp emits this whenever the discovered command set changes — after
+    // `/reload-plugins`, `/move`, or a skill install. The composer's command
+    // pool is cached five minutes (`composer/client.ts`), so without this the
+    // popup keeps offering the pre-change list.
+    case 'available_commands_update':
+      invalidateComposerCache('command');
+      break;
+
+    // Transport/extension frames (a dropped frame, a failed extension, the
+    // session's own quiescence verdict) live in `transport-frames.ts`, which
+    // also names the frames it deliberately ignores.
+    default:
+      foldTransportFrame(data, { foldDeps: deps });
+      break;
+  }
+}

package/src/shared/lib/chat/omp/available-commands-cache.test.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * `available_commands_update` must drop the composer's cached command pool.
+ * The cache lives five minutes, and this frame is the only signal that omp's
+ * discovered command set changed (`/reload-plugins`, `/move`, a skill install),
+ * so ignoring it leaves the popup offering a list omp no longer matches.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { foldAgentEvent, type OmpAgentFoldDeps } from '@/shared/lib/chat/omp/agent-events';
+import { invalidateComposerCache, loadComposerItems } from '@/shared/lib/chat/composer/client';
+
+function foldDeps(): OmpAgentFoldDeps {
+  const noop = () => {};
+  const ref = <T,>(value: T) => ({ current: value });
+  return {
+    setState: noop,
+    sessionId: 'test-session',
+    callbacksRef: { current: {} },
+    toolResultsRef: ref(new Map()),
+    lastToolMessageRef: ref(null),
+    activityRef: ref(''),
+    providerRetryVerbRef: ref(null),
+    currentThinkingLevelRef: ref(undefined),
+    fileMutatingCallsRef: ref(new Set()),
+  } as unknown as OmpAgentFoldDeps;
+}
+
+describe('available_commands_update', () => {
+  test('refetches the command pool on the next composer open', async () => {
+    let fetches = 0;
+    /** The runner's own fetch, reached through `Bun` so a stub leaked onto the global cannot be mistaken for it. */
+const originalFetch = Bun.fetch;
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      const href = String(url);
+      if (href.includes('/api/settings/commands')) {
+        fetches += 1;
+        return new Response(JSON.stringify({ commands: [] }), { status: 200 });
+      }
+      if (href.includes('/api/settings/skills')) {
+        return new Response(JSON.stringify({ skills: [] }), { status: 200 });
+      }
+      return new Response('{}', { status: 200 });
+    }) as typeof fetch;
+
+    try {
+      invalidateComposerCache();
+      await loadComposerItems('command');
+      expect(fetches).toBe(1);
+      // Cached: a second open inside the TTL does not refetch.
+      await loadComposerItems('command');
+      expect(fetches).toBe(1);
+
+      // omp reports the command set changed.
+      foldAgentEvent({ type: 'available_commands_update', commands: [] }, foldDeps());
+
+      await loadComposerItems('command');
+      expect(fetches).toBe(2);
+    } finally {
+      globalThis.fetch = originalFetch;
+      invalidateComposerCache();
+    }
+  });
+});