ompchamber 3.3.2 → 3.4.0

package/src/server/lib/omp/session/messages.ts

@@ -235,6 +235,32 @@ export async function loadSessionModel(filePath: string): Promise<{ provider: st
  *  `thinking_level_change` entries (omp records the level string, e.g.
  *  "off" | "minimal" | "low" | "medium" | "high" | "max"). */
 export async function loadSessionThinkingLevel(filePath: string): Promise<string | undefined> {
+  return readThinkingSelector(filePath, (record) => normalizeThinkingLevel(record.thinkingLevel));
+}
+
+/**
+ * The thinking SELECTOR a session is configured with — `auto` when automatic
+ * per-turn classification is on, else the concrete level.
+ *
+ * omp writes both fields on one entry (`thinkingLevel` = the provisional
+ * concrete effort, `configured` = the selector) and restores with
+ * `parseConfiguredThinkingLevel(configured) ?? parseThinkingLevel(level)`, so a
+ * reader that takes `thinkingLevel` alone turns an `auto` session into a pinned
+ * one. Anything spawning a child that must classify its turns the way the
+ * session does has to read this, not the concrete level.
+ */
+export async function loadSessionThinkingSelector(filePath: string): Promise<string | undefined> {
+  return readThinkingSelector(filePath, (record) =>
+    typeof record.configured === 'string' && record.configured
+      ? record.configured
+      : normalizeThinkingLevel(record.thinkingLevel),
+  );
+}
+
+async function readThinkingSelector(
+  filePath: string,
+  read: (record: Record<string, unknown>) => string,
+): Promise<string | undefined> {
   try {
     const file = Bun.file(filePath);
     if ((await file.stat()).size > MAX_SESSION_LOAD_BYTES) return undefined;
@@ -247,8 +273,7 @@ export async function loadSessionThinkingLevel(filePath: string): Promise<string
     let last: string | undefined;
     for (const record of records) {
       if (record?.type !== 'thinking_level_change') continue;
-      // A change entry always yields a display level: null/unset → "off".
-      last = normalizeThinkingLevel(record.thinkingLevel);
+      last = read(record);
     }
     return last;
   } catch {

package/src/server/plugins/ssr.ts

@@ -135,10 +135,10 @@ export const ssrRoutes = new Elysia({ name: 'ssr' }).get('*', async ({ request }
   const themeStyle = `<style id="${THEME_STYLE_ELEMENT_ID}">${themeStyleSheet()}</style>`;
   // The font faces are a stylesheet the bundler cannot carry: Bun resolves every
   // local `url()` in CSS, so a bundled face is either base64 or an absolute
-  // filesystem path. `lib/bundler/css.ts` lifts the blocks out and the route
-  // below serves them, which is why the link is injected here — a
-  // `<link href="/fonts.css">` in index.html would be resolved by the HTML
-  // loader and fail the same way.
+  // filesystem path. `lib/bundler/css.ts` strips the blocks out of the bundle
+  // and `lib/assets/font-css.server.ts` re-declares them on the route below,
+  // which is why the link is injected here — a `<link href="/fonts.css">` in
+  // index.html would be resolved by the HTML loader and fail the same way.
   const fontLink = `<link rel="stylesheet" href="${FONT_STYLESHEET_ROUTE}">`;
 
   // Bun's dev asset URLs move to this server's prefix so the proxy above can add

package/src/server/plugins/static.ts

@@ -2,7 +2,7 @@ import { extname, join, normalize, resolve, sep } from 'path';
 
 import { notModified } from '@/server/lib/assets/conditional.server';
 import { FONT_STYLESHEET_ROUTE, serveFontFile, serveFontStylesheet } from '@/server/lib/assets/font-css.server';
-import { FONT_ROUTE_PREFIX, packageRoot } from '@/server/lib/assets/fonts.server';
+import { FONT_ROUTE_PREFIX, packageDir } from '@/server/lib/assets/fonts.server';
 
 /**
  * File serving for `public/` and the font routes.
@@ -21,12 +21,16 @@ import { FONT_ROUTE_PREFIX, packageRoot } from '@/server/lib/assets/fonts.server
  * catch-all, which would shadow this app's SSR route. Exposing one lookup
  * function lets the web catch-all try a file first and fall back to the shell.
  */
-// Resolved from the package root, not the cwd: `serve --prod` may run the built
-// server from anywhere, and a cwd-relative `public` would not exist — every
-// icon, the manifest and the service worker would 404.
-const PUBLIC_ROOT = resolve(packageRoot(), 'public');
+// Resolved from the package's own directory, not the cwd: `serve --prod` may
+// run the built server from anywhere, and a cwd-relative `public` would not
+// exist — every icon, the manifest and the service worker would 404. The
+// package, NOT `packageRoot()`: in a hoisted install the first root holding
+// `node_modules` is the parent, where `public/` and `dist/client/` do not exist,
+// so the lookup would fall through to the shell and answer an image request with
+// HTML.
+const PUBLIC_ROOT = resolve(packageDir(), 'public');
 /** Where `scripts/build-client.ts` writes the production bundle and its chunks. */
-const CLIENT_ROOT = resolve(packageRoot(), 'dist', 'client');
+const CLIENT_ROOT = resolve(packageDir(), 'dist', 'client');
 
 const IMMUTABLE = 'public, max-age=31536000, immutable';
 const SHORT = 'public, max-age=3600';
@@ -141,12 +145,12 @@ export async function tryServeStatic(pathname: string, request?: Request): Promi
     const filePath = resolveWithin(CLIENT_ROOT, pathname);
     return filePath ? serveFile(filePath, ASSET_CACHE, request) : null;
   }
-  // The extracted `@font-face` stylesheet and the files it names. Bun's CSS
+  // The assembled `@font-face` stylesheet and the files it names. Bun's CSS
   // loader cannot carry either — every local `url()` is resolved, so a bundled
   // face is base64 or an absolute path — which is why they are served rather
-  // than emitted. Both live outside `public/`: the stylesheet is assembled from
-  // the faces `lib/bundler/css.ts` wrote, and the files come from the installed
-  // packages.
+  // than emitted. Both live outside `public/`: the stylesheet re-declares the
+  // faces `lib/bundler/css.ts` stripped, read from the source stylesheets, and
+  // the files come from the installed packages.
   //
   // Neither is given a conditional here: the stylesheet is `no-store` (nothing
   // is ever stored to revalidate) and a font file is `immutable` (the browser

package/src/server/routes/agent/command.ts

@@ -5,8 +5,9 @@ import { WebRpcError, getRpcSession, resolveSpawnCwd, startRpcSession, type Agen
 import { getSpawnApprovalMode, reconcileSpawnApprovalMode } from '@/server/lib/omp/rpc/session-registry';
 import { isApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { loadPersistedAccessMode } from '@/shared/lib/omp/config/access-mode.server';
-import { OBSERVER_ONLY_COMMANDS } from '@/server/lib/omp/rpc/constants';
+import { CONVERSATION_MOVING_COMMANDS, OBSERVER_ONLY_COMMANDS } from '@/server/lib/omp/rpc/constants';
 import { rpcErrorResponse } from '@/server/lib/omp/rpc/errors';
+import { assertBtwIdle } from '@/server/lib/btw/service.server';
 
 // POST /api/agent/:sessionId — send a command to an existing session (or spawn
 // it lazily). Mirrors omp-web's /api/agent/[id].
@@ -28,6 +29,13 @@ export async function sendCommand({ params, request }: ActionFunctionArgs) {
     // default. omp has no RPC to change the mode after spawn.
     const explicitMode = isApprovalMode(body.accessMode) ? body.accessMode : null;
 
+    // A command that moves the conversation is refused while a side question is
+    // in flight on this session — the question's snapshot describes the
+    // transcript this command would replace (omp blocks the same operations).
+    if (CONVERSATION_MOVING_COMMANDS.has(body.type)) {
+      await assertBtwIdle(sessionId, body.type.replace(/_/g, ' '));
+    }
+
     // Fast path: already-running session.
     const existing = getRpcSession(sessionId);
     if (existing?.isAlive()) {

package/src/server/routes/btw/topics.ts

@@ -14,25 +14,15 @@
 
 import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
 import { toImageContents, validateAgentImages } from '@/server/lib/omp/rpc/constants';
-import { isApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import type { AttachedTextFileData } from '@/shared/lib/chat/attachments';
 import { BtwError, type BtwImages } from '@/server/lib/btw/runtime.server';
-import {
-  abortBtw,
-  askBtw,
-  getBtwState,
-  promoteBtw,
-  removeBtw,
-  respondBtwDialog,
-  setBtwApprovalMode,
-  setBtwModel,
-  setBtwThinkingLevel,
-} from '@/server/lib/btw/service.server';
+import { abortBtw, askBtw, getBtwState, promoteBtw, removeBtw } from '@/server/lib/btw/service.server';
 
 /** Actions that can reject for a reason the client should show as-is. */
 const STATUS_BY_CODE: Record<string, number> = {
   btw_busy: 409,
   btw_stale: 409,
+  btw_multi_turn: 409,
   session_not_found: 404,
   btw_topic_not_found: 404,
 };
@@ -71,20 +61,6 @@ function readTextFiles(raw: unknown): AttachedTextFileData[] {
   });
 }
 
-/**
- * The response body for one dialog, in the shape omp's RPC accepts: an answer
- * value, a confirmation, or a cancellation. Anything else is refused rather
- * than forwarded — a malformed response would leave the child blocked.
- */
-function readDialogResponse(raw: unknown): Record<string, unknown> | null {
-  if (!raw || typeof raw !== 'object') return null;
-  const response = raw as { value?: unknown; confirmed?: unknown; cancelled?: unknown };
-  if (response.cancelled === true) return { cancelled: true };
-  if (typeof response.confirmed === 'boolean') return { confirmed: response.confirmed };
-  if (typeof response.value === 'string') return { value: response.value };
-  return null;
-}
-
 export async function action({ params, request }: ActionFunctionArgs) {
   const { sessionId } = params;
   if (!sessionId) return json({ error: 'session id is required' }, { status: 400 });
@@ -100,8 +76,6 @@ export async function action({ params, request }: ActionFunctionArgs) {
         const question = typeof body?.question === 'string' ? body.question : '';
         const parsed = readImages(body?.images);
         if ('error' in parsed) return json({ error: parsed.error, code: 'invalid_images' }, { status: 400 });
-        const provider = typeof body?.provider === 'string' ? body.provider : '';
-        const modelId = typeof body?.modelId === 'string' ? body.modelId : '';
         return json({
           success: true,
           data: await askBtw(sessionId, {
@@ -109,9 +83,6 @@ export async function action({ params, request }: ActionFunctionArgs) {
             question,
             images: parsed.images,
             textFiles: readTextFiles(body?.textFiles),
-            ...(provider && modelId ? { model: { provider, id: modelId } } : {}),
-            ...(typeof body?.thinkingLevel === 'string' ? { thinkingLevel: body.thinkingLevel } : {}),
-            ...(isApprovalMode(body?.accessMode) ? { approvalMode: body.accessMode } : {}),
           }),
         });
       }
@@ -119,34 +90,6 @@ export async function action({ params, request }: ActionFunctionArgs) {
         if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
         return json({ success: true, data: await abortBtw(sessionId, topicId) });
       }
-      case 'set_model': {
-        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
-        const provider = typeof body?.provider === 'string' ? body.provider : '';
-        const modelId = typeof body?.modelId === 'string' ? body.modelId : '';
-        if (!provider || !modelId) return json({ error: 'provider and modelId are required', code: 'model_required' }, { status: 400 });
-        return json({ success: true, data: await setBtwModel(sessionId, topicId, provider, modelId) });
-      }
-      case 'set_thinking_level': {
-        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
-        const level = typeof body?.level === 'string' ? body.level : '';
-        if (!level) return json({ error: 'level is required', code: 'level_required' }, { status: 400 });
-        return json({ success: true, data: await setBtwThinkingLevel(sessionId, topicId, level) });
-      }
-      case 'set_access_mode': {
-        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
-        if (!isApprovalMode(body?.accessMode)) {
-          return json({ error: 'accessMode must be always-ask, write or yolo', code: 'invalid_access_mode' }, { status: 400 });
-        }
-        return json({ success: true, data: await setBtwApprovalMode(sessionId, topicId, body.accessMode) });
-      }
-      case 'dialog_response': {
-        if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
-        const id = typeof body?.id === 'string' ? body.id : '';
-        if (!id) return json({ error: 'id is required', code: 'dialog_required' }, { status: 400 });
-        const response = readDialogResponse(body?.response);
-        if (!response) return json({ error: 'a response value is required', code: 'dialog_required' }, { status: 400 });
-        return json({ success: true, data: await respondBtwDialog(sessionId, topicId, id, response) });
-      }
       case 'promote': {
         if (!topicId) return json({ error: 'topicId is required', code: 'topic_required' }, { status: 400 });
         return json({ success: true, data: await promoteBtw(sessionId, topicId) });

package/src/shared/lib/chat/btw/client.ts

@@ -15,7 +15,6 @@
 
 import type { AgentImage, BtwFrame, BtwState, StreamTransport } from '@/shared/types';
 import type { AttachedTextFileData } from '@/shared/lib/chat/attachments';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { connectEvents } from '@/shared/lib/chat/omp/sse';
 import { connectSocket } from '@/shared/lib/chat/omp/socket';
 import { btwEventsUrl, btwSocketUrl } from '@/shared/lib/chat/omp/transport';
@@ -74,11 +73,6 @@ export interface AskBtwInput {
   images?: AgentImage[];
   /** Text files inlined for this question (read at attach time by the composer). */
   textFiles?: AttachedTextFileData[];
-  /** Composer picks for a FIRST question — a topic that does not exist yet has
-   *  no row to hold them, so they ride the ask and reach the spawn. */
-  model?: { provider: string; id: string };
-  thinkingLevel?: string;
-  approvalMode?: ApprovalMode;
 }
 
 export function askBtwQuestion(sessionId: string, input: AskBtwInput): Promise<BtwState> {
@@ -88,9 +82,6 @@ export function askBtwQuestion(sessionId: string, input: AskBtwInput): Promise<B
     ...(input.topicId ? { topicId: input.topicId } : {}),
     ...(input.images?.length ? { images: input.images } : {}),
     ...(input.textFiles?.length ? { textFiles: input.textFiles } : {}),
-    ...(input.model ? { provider: input.model.provider, modelId: input.model.id } : {}),
-    ...(input.thinkingLevel ? { thinkingLevel: input.thinkingLevel } : {}),
-    ...(input.approvalMode ? { accessMode: input.approvalMode } : {}),
   });
 }
 
@@ -98,27 +89,6 @@ export function abortBtwQuestion(sessionId: string, topicId: string): Promise<Bt
   return requestBtw<BtwState>(sessionId, 'POST', { action: 'abort', topicId });
 }
 
-export function setBtwModel(sessionId: string, topicId: string, provider: string, modelId: string): Promise<BtwState> {
-  return requestBtw<BtwState>(sessionId, 'POST', { action: 'set_model', topicId, provider, modelId });
-}
-
-export function setBtwThinkingLevel(sessionId: string, topicId: string, level: string): Promise<BtwState> {
-  return requestBtw<BtwState>(sessionId, 'POST', { action: 'set_thinking_level', topicId, level });
-}
-
-export function setBtwAccessMode(sessionId: string, topicId: string, accessMode: ApprovalMode): Promise<BtwState> {
-  return requestBtw<BtwState>(sessionId, 'POST', { action: 'set_access_mode', topicId, accessMode });
-}
-
-export function respondBtwDialog(
-  sessionId: string,
-  topicId: string,
-  id: string,
-  response: { value: string } | { confirmed: boolean } | { cancelled: true },
-): Promise<BtwState> {
-  return requestBtw<BtwState>(sessionId, 'POST', { action: 'dialog_response', topicId, id, response });
-}
-
 export function promoteBtwTopic(sessionId: string, topicId: string): Promise<{ sessionId: string }> {
   return requestBtw<{ sessionId: string }>(sessionId, 'POST', { action: 'promote', topicId });
 }

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

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The TUI-only guard. Two failure modes matter and both are silent:
+ *
+ * - a name omp DOES implement over RPC gets refused, so a working command stops
+ *   working in the chamber. That is why the table is asserted against omp's own
+ *   registry rather than trusted, and why the predicate is name-only.
+ * - a name omp does NOT implement slips through, which is the bug this module
+ *   exists for: the prompt reaches the model as literal text and it improvises a
+ *   turn around the string.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { isTuiOnlySlashCommand, slashCommandName, tuiOnlyCommandNotice } from '@/shared/lib/chat/composer/tui-only';
+
+describe('slashCommandName', () => {
+  test('reads the token omp would dispatch on', () => {
+    expect(slashCommandName('/plan')).toBe('plan');
+    expect(slashCommandName('/PLAN')).toBe('plan');
+    // Arguments, colon form, and leading whitespace all resolve to the name.
+    expect(slashCommandName('/move /tmp/x')).toBe('move');
+    expect(slashCommandName('/force:write')).toBe('force');
+    expect(slashCommandName('   /clear')).toBe('clear');
+  });
+
+  test('a slash that is not a command is not a name', () => {
+    expect(slashCommandName('fix a/b')).toBeNull();
+    expect(slashCommandName('see /tmp/foo')).toBeNull();
+    expect(slashCommandName('prose\n/plan')).toBeNull();
+    expect(slashCommandName('/')).toBeNull();
+    expect(slashCommandName('')).toBeNull();
+  });
+});
+
+describe('isTuiOnlySlashCommand', () => {
+  test('refuses the commands omp only implements in its TUI', () => {
+    for (const command of ['/plan', '/clear', '/new', '/login', '/hotkeys', '/tree', '/resume', '/quit', '/exit']) {
+      expect(isTuiOnlySlashCommand(command)).toBe(true);
+    }
+    // Aliases count: omp resolves these to the same TUI-only entry.
+    expect(isTuiOnlySlashCommand('/providers')).toBe(true);
+    expect(isTuiOnlySlashCommand('/q')).toBe(true);
+    expect(isTuiOnlySlashCommand('/status')).toBe(true);
+    expect(isTuiOnlySlashCommand('/rewind')).toBe(true);
+  });
+
+  test('lets every command omp answers over RPC through', () => {
+    // Sampled from the 42 entries carrying a text-mode `handle`; a false
+    // positive here silently breaks a working command.
+    for (const command of [
+      '/model',
+      '/context',
+      '/usage',
+      '/compact',
+      '/todo',
+      '/mcp list',
+      '/rename x',
+      '/move /tmp',
+      '/session info',
+      '/skill:diagnose',
+      '/review',
+    ]) {
+      expect(isTuiOnlySlashCommand(command)).toBe(false);
+    }
+  });
+
+  test('does NOT refuse a command the chamber answers itself', () => {
+    // `/btw` is TUI-only in omp, but the chamber owns it: the composer opens
+    // the side-question panel. Refusing it here broke a working feature.
+    expect(isTuiOnlySlashCommand('/btw')).toBe(false);
+    expect(isTuiOnlySlashCommand('/btw how does this work')).toBe(false);
+  });
+
+  test('ordinary prose is never a command', () => {
+    expect(isTuiOnlySlashCommand('explain the plan')).toBe(false);
+    expect(isTuiOnlySlashCommand('what does /clear do?')).toBe(false);
+    expect(isTuiOnlySlashCommand('')).toBe(false);
+  });
+});
+
+describe('tuiOnlyCommandNotice', () => {
+  test('names the command and says where it works', () => {
+    const notice = tuiOnlyCommandNotice('/plan do the thing');
+    expect(notice).toContain('`/plan`');
+    expect(notice).toContain('omp terminal only');
+  });
+});

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;