ompchamber 3.3.3 → 3.4.0

package/src/shared/lib/chat/composer/tui-only.ts

@@ -0,0 +1,138 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Slash commands oh-my-pi implements only for its own TUI.
+ *
+ * omp's registry carries a `handle` (text/ACP mode) for 42 of its 82 builtins
+ * and `handleTui` alone for the other 40. `executeAcpBuiltinSlashCommand`
+ * requires `handle`, and `buildAvailableSlashCommands` skips entries without
+ * one — which is why none of these names appear in the composer popup.
+ *
+ * The popup is not the whole surface: a name can still be typed, pasted from
+ * the docs, or arrive through the follow-up queue. RPC forwards such a prompt
+ * to `session.prompt()` verbatim, where the only slash handling left is file
+ * commands and prompt templates — so `/plan` reaches the MODEL as literal text
+ * and it improvises a turn around it. Measured on omp 18.3.5: `/hotkeys`
+ * started a run whose transcript opened with the raw string, the model read
+ * `omp://slash-command-internals.md` and ran bash and grep to work out what it
+ * meant. `/clear` cleared nothing, `/new` opened nothing, `/login` logged in
+ * nothing. The TUI answers all of these instantly and locally.
+ *
+ * The table is data extracted from the installed omp's own registry, so a name
+ * omp moves to text mode stops being guarded by deleting its row. It is
+ * deliberately keyed on NAMES ONLY: the guard must not depend on the version of
+ * the running child, because a chamber talking to an older omp would otherwise
+ * refuse a command that build actually implements.
+ *
+ * `btw` is listed because omp's entry is TUI-only — the chamber's own `/btw`
+ * is intercepted before this predicate is consulted (see `dispatchBtwCommand`),
+ * so the two never conflict.
+ */
+
+import { CHAMBER_COMMANDS } from '@/shared/lib/chat/composer/trigger';
+
+/**
+ * Commands the CHAMBER answers itself, derived from the one list that defines
+ * them. They are in omp's TUI-only set (omp implements `/btw` with `handleTui`
+ * only) but they are NOT unavailable here — the composer intercepts them before
+ * any guard runs.
+ *
+ * Derived rather than restated: a second hand-kept list is exactly what drifts,
+ * and a name that moved into `CHAMBER_COMMANDS` without a matching row here
+ * would be refused by the very guard that exists to protect it.
+ */
+export const CHAMBER_OWNED_SLASH_COMMANDS: Record<string, true> = Object.fromEntries(
+  CHAMBER_COMMANDS.map((command) => [command.name.toLowerCase(), true as const]),
+);
+
+/** Every TUI-only builtin name and alias, lowercased. */
+export const TUI_ONLY_SLASH_COMMANDS: Record<string, true> = {
+  settings: true,
+  setup: true,
+  providers: true,
+  plan: true,
+  'plan-review': true,
+  vibe: true,
+  goal: true,
+  'guided-goal': true,
+  loop: true,
+  queue: true,
+  collab: true,
+  join: true,
+  leave: true,
+  copy: true,
+  open: true,
+  hotkeys: true,
+  extensions: true,
+  status: true,
+  agents: true,
+  git: true,
+  hub: true,
+  branch: true,
+  rewind: true,
+  fork: true,
+  tree: true,
+  login: true,
+  logout: true,
+  new: true,
+  clear: true,
+  delete: true,
+  resume: true,
+  btw: true,
+  tan: true,
+  omfg: true,
+  cleanse: true,
+  debug: true,
+  exit: true,
+  restart: true,
+  skills: true,
+  live: true,
+  record: true,
+  pause: true,
+  quit: true,
+  q: true,
+};
+
+/** The command token of a draft, lowercased, or null when it is not a slash
+ *  invocation. Mirrors omp's own parse: the name ends at the first space or
+ *  colon, and the token must START the prompt (leading whitespace allowed) —
+ *  a `/` inside prose is a path, not a command. */
+export function slashCommandName(text: string): string | null {
+  const trimmed = text.trimStart();
+  if (!trimmed.startsWith('/')) return null;
+  const rest = trimmed.slice(1);
+  const end = rest.search(/[\s:]/);
+  const name = end === -1 ? rest : rest.slice(0, end);
+  return name ? name.toLowerCase() : null;
+}
+
+/**
+ * Whether a draft invokes a command the chamber cannot run, because omp only
+ * implements it in its TUI. Such a prompt must be refused locally — forwarding
+ * it makes the model answer a command it never received.
+ *
+ * A command the CHAMBER owns is excluded: `/btw` is TUI-only in omp, but the
+ * chamber answers it with the side-question panel, so refusing it here would
+ * break a working feature. The client intercepts those before consulting this
+ * predicate; the exclusion is what keeps the SERVER-side guard (which sees only
+ * the text, e.g. on a queued delivery) from refusing them too.
+ */
+export function isTuiOnlySlashCommand(text: string): boolean {
+  const name = slashCommandName(text);
+  if (name === null) return false;
+  if (CHAMBER_OWNED_SLASH_COMMANDS[name] === true) return false;
+  return TUI_ONLY_SLASH_COMMANDS[name] === true;
+}
+
+/**
+ * The notice shown in place of a refused turn. Names the command and says where
+ * it does work, because "not supported" alone leaves the user guessing whether
+ * they mistyped it.
+ */
+export function tuiOnlyCommandNotice(text: string): string {
+  const name = slashCommandName(text) ?? text.trim();
+  return `\`/${name}\` is available in the omp terminal only — it has no effect over the RPC bridge, so it was not sent.`;
+}

package/src/shared/lib/chat/notice-text.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The one normalization every notice row's text goes through.
+ *
+ * Two paths produce the same row and they must agree, or a command's output
+ * changes appearance when the page is refreshed: the live `command_output`
+ * frame (`chat/omp/agent-events.ts`) and the custom entry a reload replays
+ * (`omp/session/messages-map.ts`).
+ *
+ * What it removes, and why:
+ *
+ * - **ANSI escapes.** omp formats command output for a terminal — SGR colour
+ *   runs and half-block progress bars. The notice card renders markdown through
+ *   Shiki, which treats `\x1b[38;2;…m` as literal text, so `/context` drew 48
+ *   escape bytes as `38;2;107;114;128m████…`. True colour stays available in the
+ *   realtime xterm panel, which parses ANSI natively.
+ * - **`<system-notice>` wrappers.** omp tags its own notices; the tag is
+ *   scaffolding, not content. (`<system-reminder>` / `<task-result>` are NOT
+ *   stripped — those identify the card variant `SystemNotice` renders.)
+ */
+
+import { stripAnsiCodes } from '@/shared/lib/code/ansi';
+
+/** Strip terminal formatting and notice scaffolding, then trim. */
+export function normalizeNoticeText(text: string): string {
+  return stripAnsiCodes(text)
+    .replace(/<\/?system-notice[^>]*>/g, '')
+    .trim();
+}

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

@@ -13,9 +13,11 @@
  * size ceiling.
  */
 
-import type { Dispatch, RefObject, SetStateAction } from 'preact/compat';
-import type { ChatMessageData, IncomingExtensionUiRequest, OmpAgentCallbacks, OmpAgentEvent, OmpAgentState, ToolCallData } from '@/shared/types';
+import type { IncomingExtensionUiRequest, OmpAgentCallbacks, OmpAgentEvent, ToolCallData } from '@/shared/types';
 import { extractTextFromContent, toChatMessage, toolResultText } from '@/shared/lib/omp/session/mapper';
+import { normalizeNoticeText } from '@/shared/lib/chat/notice-text';
+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 { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
 import { describeAssistantPhase, describeToolActivity } from '@/shared/lib/chat/timeline/tool-verbs';
@@ -25,43 +27,13 @@ import {
   putToolResult,
   recordToolResult,
   refreshToolMessage,
-  type ToolResultHost,
   type ToolResultRecord,
 } from '@/shared/lib/chat/omp/tool-results';
 
 // 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 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). */
-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. */
-function toolHost(deps: OmpAgentFoldDeps): ToolResultHost {
-  return { ...deps, onMessageUpdate: deps.callbacksRef.current?.onMessageUpdate };
-}
+export type { OmpAgentFoldDeps } from '@/shared/lib/chat/omp/fold-deps';
 
 /** Flush assistant turns that stopped abnormally and were never streamed as
  *  `message_end`. A user abort is the one terminal path where omp emits no
@@ -274,8 +246,10 @@ export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): voi
 
     // 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' ? data.text.trim() : '';
+      const text = typeof data.text === 'string' ? normalizeNoticeText(data.text) : '';
       if (text) callbacks?.onCommandOutput?.(text);
       break;
     }
@@ -329,10 +303,17 @@ export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): voi
       deps.currentThinkingLevelRef.current = normalizeThinkingLevel(data.thinkingLevel);
       break;
 
-    // No chamber-side effect: config/command inventory frames and the
-    // transport's own `connected` greeting.
-    case 'config_update':
+    // 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;
+
+    // No chamber-side effect: config frames and the transport's own `connected`
+    // greeting.
+    case 'config_update':
     case 'connected':
     default:
       break;

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,