ompchamber 3.3.2 → 3.4.0

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

@@ -0,0 +1,66 @@
+/**
+ * @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),
+    interruptPendingRef: ref(false),
+    activityRef: ref(''),
+    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;
+    const originalFetch = globalThis.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();
+    }
+  });
+});

package/src/shared/lib/chat/omp/command-output-ansi.test.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Builtin-command output must be stripped of ANSI on BOTH paths that can render
+ * it: the live `command_output` frame and the custom entry a reload replays.
+ * The two are separate code paths, and a fix applied to only one makes a
+ * command's output change appearance when the page is refreshed — measured on
+ * `/context`, whose progress bars carry 48 escape bytes that the notice card
+ * drew literally as `38;2;107;114;128m████…`.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { foldAgentEvent, type OmpAgentFoldDeps } from '@/shared/lib/chat/omp/agent-events';
+import { noticeFromCustomMessage } from '@/shared/lib/omp/session/messages-map';
+
+/** The real shape omp emits for `/context`: SGR runs around half-block bars. */
+const CONTEXT_OUTPUT = 'Context window: 1000000 tokens (1% used)\n'
+  + '  System prompt    [\u001b[38;2;107;114;128m░░░░░░\u001b[39m\u001b[1m\u001b[38;2;0;180;255m░░░░\u001b[22m\u001b[39m] 0%  2541 tokens';
+
+function foldDeps(): { deps: OmpAgentFoldDeps; outputs: string[] } {
+  const outputs: string[] = [];
+  const noop = () => {};
+  const ref = <T,>(value: T) => ({ current: value });
+  const deps = {
+    setState: noop,
+    sessionId: 'test-session',
+    callbacksRef: {
+      current: {
+        onCommandOutput: (text: string) => outputs.push(text),
+      },
+    },
+    toolResultsRef: ref(new Map()),
+    lastToolMessageRef: ref(null),
+    interruptPendingRef: ref(false),
+    activityRef: ref(''),
+    currentThinkingLevelRef: ref(undefined),
+    fileMutatingCallsRef: ref(new Set()),
+  } as unknown as OmpAgentFoldDeps;
+  return { deps, outputs };
+}
+
+describe('command_output ANSI stripping (live path)', () => {
+  test('strips escapes before the notice row sees them', () => {
+    const { deps, outputs } = foldDeps();
+    foldAgentEvent({ type: 'command_output', text: CONTEXT_OUTPUT }, deps);
+
+    expect(outputs).toHaveLength(1);
+    expect(outputs[0]).not.toContain('\u001b');
+    // The content itself survives — only the escapes go.
+    expect(outputs[0]).toContain('Context window: 1000000 tokens');
+    expect(outputs[0]).toContain('░░░░░░');
+  });
+
+  test('keeps the empty-frame guard', () => {
+    const { deps, outputs } = foldDeps();
+    foldAgentEvent({ type: 'command_output', text: '  \u001b[39m ' }, deps);
+    expect(outputs).toEqual([]);
+  });
+});
+
+describe('noticeFromCustomMessage ANSI stripping (reload path)', () => {
+  test('strips escapes from a replayed custom entry', () => {
+    const notice = noticeFromCustomMessage({
+      type: 'custom_message',
+      customType: 'command_output',
+      content: CONTEXT_OUTPUT,
+    });
+
+    expect(notice).not.toBeNull();
+    expect(notice?.notice).not.toContain('\u001b');
+    expect(notice?.notice).toContain('Context window: 1000000 tokens');
+  });
+
+  test('still unwraps a system-notice envelope', () => {
+    const notice = noticeFromCustomMessage({
+      type: 'custom_message',
+      customType: 'notice',
+      content: '<system-notice>\u001b[32mAll good\u001b[39m</system-notice>',
+    });
+    expect(notice?.notice).toBe('All good');
+  });
+});

package/src/shared/lib/chat/omp/fold-deps.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The deps record `foldAgentEvent` reads, plus the two small helpers that
+ * narrow it. Split out of `agent-events.ts` so that file — which is already the
+ * switch over every frame omp can send — stays under the repo's per-file size
+ * ceiling.
+ *
+ * These are pure accessors over caller-owned state: no closure of their own, no
+ * module state, so importing them from either side of the fold is free.
+ */
+
+import type { Dispatch, RefObject, SetStateAction } from 'preact/compat';
+import type { ChatMessageData, OmpAgentCallbacks, OmpAgentState } from '@/shared/types';
+import type { ToolResultHost, ToolResultRecord } from '@/shared/lib/chat/omp/tool-results';
+
+export interface OmpAgentFoldDeps extends ToolResultHost {
+  sessionId: string;
+  setState: Dispatch<SetStateAction<OmpAgentState>>;
+  callbacksRef: RefObject<OmpAgentCallbacks>;
+  toolResultsRef: RefObject<Map<string, ToolResultRecord>>;
+  lastToolMessageRef: RefObject<ChatMessageData>;
+  interruptPendingRef: RefObject<boolean>;
+  /** Last activity phrase published to the indicator; guards per-token frames
+   *  from re-setting identical state. */
+  activityRef: RefObject<string>;
+  /** Thinking level in effect for the live run (last `thinking_level_changed`
+   *  frame); stamped onto assistant turns as they stream. */
+  currentThinkingLevelRef: RefObject<string | undefined>;
+  /** toolCallIds of in-flight file-mutating calls, cleared on `agent_start`. */
+  fileMutatingCallsRef: RefObject<Set<string>>;
+}
+
+/** Publish a new indicator phrase, skipping repeats (thinking/text deltas
+ *  arrive per token and would otherwise re-set state on every frame). */
+export function setActivity(verb: string | undefined, deps: OmpAgentFoldDeps): void {
+  if (!verb || verb === deps.activityRef.current) return;
+  deps.activityRef.current = verb;
+  deps.callbacksRef.current?.onActivity?.(verb);
+}
+
+/** Narrow a deps record to the tool-output host, adding the re-emit sink. */
+export function toolHost(deps: OmpAgentFoldDeps): ToolResultHost {
+  return { ...deps, onMessageUpdate: deps.callbacksRef.current?.onMessageUpdate };
+}

package/src/shared/lib/chat/timeline/command-output.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The `command_output` fold step: a builtin command's result becomes a notice
+ * row, and that row is PERSISTED.
+ *
+ * Persistence is the point. omp answers a builtin on the command path and
+ * writes nothing to the session JSONL — the output exists only in this frame —
+ * so a timeline rebuilt from the file had forgotten a `/context` the user just
+ * ran. The chamber's own copy keeps it, and `mergeOmpAttachments` splices it
+ * back under the turn that produced it on the next load.
+ *
+ * Split out of `omp-callbacks.ts` (which keeps only the wiring) so both files
+ * stay under the repo's per-file size ceiling.
+ */
+
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { ChatMessageData } from '@/shared/types';
+
+export interface CommandOutputDeps {
+  setLocalMessages: Dispatch<SetStateAction<ChatMessageData[]>>;
+  /** The optimistic AI bubble this run is streaming into, if any. */
+  aiPlaceholderIdRef: { current: string | null };
+  persistMessages: (messages: ChatMessageData[]) => void;
+}
+
+/**
+ * Append a command's output as a notice row, before the active placeholder.
+ *
+ * Placing it before the placeholder is what keeps it under the turn that
+ * produced it: the placeholder becomes the assistant's answer, and the notice
+ * must read as the command's result rather than as part of that answer. With no
+ * placeholder the row goes at the tail.
+ */
+export function appendCommandOutputNotice(text: string, deps: CommandOutputDeps): void {
+  const { setLocalMessages, aiPlaceholderIdRef, persistMessages } = deps;
+  const row: ChatMessageData = {
+    id: `cmdout-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    role: 'ai',
+    content: '',
+    notice: text,
+  };
+  setLocalMessages(prev => {
+    const placeholderId = aiPlaceholderIdRef.current;
+    const pIdx = placeholderId ? prev.findIndex(m => m.id === placeholderId) : -1;
+    if (pIdx !== -1) {
+      const next = [...prev.slice(0, pIdx), row, ...prev.slice(pIdx)];
+      // The streaming placeholder is deliberately NOT persisted — it is a
+      // client-side bubble that `onPromptSettled` removes, and executeSend
+      // filters it for the same reason. Writing it here left an empty assistant
+      // row in the chamber's copy of a command-only turn.
+      persistMessages(next.filter(m => m.id !== placeholderId));
+      return next;
+    }
+    // Already recorded (the same command re-run while nothing streams): keep
+    // the list as-is rather than stacking an identical card.
+    if (prev.some(m => m.notice === text)) return prev;
+    const next = [...prev, row];
+    persistMessages(next);
+    return next;
+  });
+}

package/src/shared/lib/chat/timeline/omp-callbacks.ts

@@ -23,6 +23,7 @@ import {
   queueStreamingUpdate,
 } from '@/shared/lib/chat/timeline/stream-coalescer';
 import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
+import { appendCommandOutputNotice } from '@/shared/lib/chat/timeline/command-output';
 
 export interface OmpAgentCallbacksDeps {
   setGenerating: (v: boolean) => void;
@@ -303,24 +304,10 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
         });
       }
     },
-    // Built-in slash command output only rides the live stream — append it as
-    // a notice row before any active placeholder, exactly like omp notices.
+    // Built-in slash command output: a notice row, persisted — see the module
+    // doc for why the chamber's own copy is the only place it can survive.
     onCommandOutput: (text) => {
-      const row: ChatMessageData = {
-        id: `cmdout-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-        role: 'ai',
-        content: '',
-        notice: text,
-      };
-      setLocalMessages(prev => {
-        const placeholderId = aiPlaceholderIdRef.current;
-        if (placeholderId) {
-          const pIdx = prev.findIndex(m => m.id === placeholderId);
-          if (pIdx !== -1) return [...prev.slice(0, pIdx), row, ...prev.slice(pIdx)];
-        }
-        if (prev.some(m => m.notice === text)) return prev;
-        return [...prev, row];
-      });
+      appendCommandOutputNotice(text, { setLocalMessages, aiPlaceholderIdRef, persistMessages });
     },
     // omp renamed the session — the auto-title generation the chamber asks for
     // after a settled run, a `/rename`, or an RPC set_session_name. The slot

package/src/shared/lib/omp/session/messages-map.ts

@@ -6,6 +6,7 @@
 import type { ChatMessageData } from '@/shared/types/chat';
 import { extractInlinedTextAttachments, extractText, extractUserImageAttachments, parseAssistantContent, resultOutput, roleFor, stripInlinedTextAttachments, type OmpMessageEntry } from '@/shared/lib/omp/session/messages-parse';
 import { isRecord } from '@/shared/lib/util/guards';
+import { normalizeNoticeText } from '@/shared/lib/chat/notice-text';
 import { reminderPartIndex } from '@/shared/lib/chat/notice-row';
 import { deriveTurnError } from '@/shared/lib/omp/session/turn-error';
 import { toEpochMs } from '@/shared/lib/omp/session/timestamps';
@@ -180,7 +181,11 @@ export function noticeFromCustomMessage(record: Record<string, unknown>): ChatMe
           .map((b) => (isRecord(b) && b.type === 'text' && typeof b.text === 'string' ? b.text : ''))
           .join('')
       : '';
-  const notice = text.replace(/<\/?system-notice[^>]*>/g, '').trim();
+  // Same terminal-formatted text the live `command_output` frame carries: a
+  // custom entry replayed from the JSONL keeps its ANSI runs, and the notice
+  // card renders them literally. One normalizer serves both paths so a command's
+  // output looks identical whether it was just run or reloaded.
+  const notice = normalizeNoticeText(text);
   if (!notice) return null;
   return {
     id,

package/src/shared/types/btw.ts

@@ -13,18 +13,21 @@
  * `btw_message` frames in the chat's own `ChatMessageData` shape, and the
  * running turn is also carried in `BtwState.live` so a client attaching
  * mid-turn renders the answer already produced.
+ *
+ * A side question runs WITHOUT tools and on the CHAT's model and thinking
+ * selector, so there is no per-topic model/access picker and no approval dialog
+ * to answer — the panel's composer is an input and a send button, exactly like
+ * the TUI's.
  */
 
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import type { ChatMessageData } from '@/shared/types/chat';
-import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
 
 /** Lifecycle of one question/answer pair inside a topic. */
-export type BtwTurnStatus = 'running' | 'complete' | 'cancelled' | 'failed' | 'interrupted';
+export type BtwTurnStatus = 'running' | 'complete' | 'cancelled' | 'error' | 'interrupted';
 
 /** Model a topic's side conversation runs on — the parent session's model,
- *  captured when the topic was created (omp's `/btw` uses the active model),
- *  then re-targeted by the panel's own model dropdown. */
+ *  re-read from the chat's transcript at every ask (omp's `/btw` runs the side
+ *  turn on `request.session.model`), so the panel offers no model picker. */
 export interface BtwModel {
   provider: string;
   id: string;
@@ -63,17 +66,11 @@ export interface BtwTopic {
   updatedAt: number;
   model?: BtwModel;
   /**
-   * Thinking level the side child runs at, or undefined for omp's own default.
-   * The panel's thinking dropdown writes it, and a change is applied with
-   * `set_thinking_level` on the live child.
+   * Thinking SELECTOR the side child runs at (`auto` included), re-read from the
+   * chat's transcript at every ask so a level changed in the chat is mirrored.
+   * Undefined when the chat's transcript records none.
    */
   thinkingLevel?: string;
-  /**
-   * Tool-approval mode the side child was SPAWNED with. omp exposes no RPC for
-   * this, so a change destroys and respawns an idle child — the same reconcile
-   * the chat session does (`reconcileSpawnApprovalMode`).
-   */
-  approvalMode?: ApprovalMode;
   /** Set once the topic was promoted into the chat as a session of its own. */
   promotedSessionId?: string;
   turns: BtwTurn[];
@@ -85,13 +82,12 @@ export interface BtwTopic {
  * Part of the state rather than only a stream of frames: a client that attaches
  * mid-turn (a reload, a second tab) would otherwise receive a `btw_state` whose
  * running turn still has no persisted messages and would show an empty answer
- * while the child streams on. Same reasoning as `dialogs` — the request never
- * comes again, so the state has to carry it.
+ * while the child streams on.
  */
 export interface BtwLiveTurn {
   topicId: string;
   turnIndex: number;
-  /** Chat-shaped conversation so far (thinking, tool calls, prose). */
+  /** Chat-shaped conversation so far (thinking and prose). */
   messages: ChatMessageData[];
   /** Activity phrase for the panel's indicator; '' before the child reports one. */
   activity: string;
@@ -105,23 +101,6 @@ export interface BtwState {
   runningTopicId: string | null;
   /** The running turn's live conversation, or null when nothing is in flight. */
   live: BtwLiveTurn | null;
-  /**
-   * Dialogs a side child is blocked on right now, oldest first. Part of the
-   * state rather than its own frame so a reload (or a fresh panel) replays the
-   * modal a child is waiting on — omp never re-delivers the request, so a lost
-   * one leaves the turn blocked with nothing to answer.
-   */
-  dialogs: BtwDialog[];
-}
-
-/**
- * A dialog the side child is blocked on. The panel renders it with the chat's
- * own `ExtensionDialog`; unlike the chat there is no tool card to host an `ask`
- * inline, so every answerable request is a modal.
- */
-export interface BtwDialog {
-  topicId: string;
-  request: ExtensionUiDialogRequest;
 }
 
 /** Server → client frames on `/api/btw/:sessionId/*` (WS and SSE alike). */