ompchamber 3.3.3 → 3.4.0

package/src/server/lib/omp/rpc/session-commands.ts

@@ -15,6 +15,7 @@ import { clearSessionFileCaches } from '@/server/lib/omp/session/files';
 import { scheduleQueueDelivery } from '@/server/lib/queue/delivery.server';
 import { clearStreamStatus, markStreamStatus } from '@/shared/lib/omp/session/stream-state.server';
 import { buildWebState, type WebStateHost } from '@/server/lib/omp/rpc/web-state';
+import { isTuiOnlySlashCommand, tuiOnlyCommandNotice } from '@/shared/lib/chat/composer/tui-only';
 
 /** Runtime surface AgentSessionWrapper exposes to the command dispatcher. */
 export interface SessionCommandHost extends WebStateHost {
@@ -50,6 +51,44 @@ async function settleCommandTimeout(host: SessionCommandHost): Promise<never> {
   throw new WebRpcError('The OMP session stopped responding and was reset.', 'session_unresponsive');
 }
 
+/**
+ * Refuse a prompt that invokes a command omp implements only in its TUI, and
+ * report it the way omp reports a real command result.
+ *
+ * This is the SERVER half of the guard in
+ * `client/hooks/chat/timeline/tui-only-guard.ts`. It exists because one prompt
+ * path never passes through the composer: the follow-up queue's auto-delivery
+ * calls `session.send({ type: 'prompt' })` directly from
+ * `lib/queue/delivery.server.ts`. A `/plan` queued before a run would otherwise
+ * be delivered to the model as literal text once the run ends.
+ *
+ * The refusal is framed as a real command result — a `command_output` notice
+ * plus, for a non-streaming prompt, the `agentInvoked:false` ack — so the
+ * client's existing fold renders the notice and settles the optimistic spinner
+ * with no new protocol.
+ *
+ * `streaming` is the caller's own knowledge of whether a turn is running: a
+ * steer of a refused command must not clear the flags of the turn it was aimed
+ * at (omp runs `session.steer()` with no slash handling at all, so a steer of
+ * `/plan` is exactly as meaningless as a fresh one).
+ *
+ * Returns true when the prompt was refused (the caller must not dispatch).
+ */
+function refuseTuiOnlyPrompt(host: SessionCommandHost, message: unknown, streaming: boolean): boolean {
+  if (typeof message !== 'string' || !isTuiOnlySlashCommand(message)) return false;
+  host.emit({ type: 'command_output', text: tuiOnlyCommandNotice(message) });
+  if (!streaming) {
+    host.promptRunning = false;
+    host.awaitingAgentStart = false;
+    host.awaitingAgentStartDeadline = 0;
+    host.emit({ type: 'prompt_result', agentInvoked: false });
+    // Nothing ran, so the queue may hold the next item — give it the same
+    // delivery window a real consumed builtin or a run end would.
+    scheduleQueueDelivery(host);
+  }
+  return true;
+}
+
 export async function dispatchSessionCommand(host: SessionCommandHost, command: Record<string, unknown>): Promise<unknown> {
   if (host.restarting) throw new WebRpcError(RESTARTING_MESSAGE, 'session_restarting');
   if (!host.isAlive()) throw new Error('Session is no longer running');
@@ -66,6 +105,11 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
       if (host.bashRunning) {
         throw new Error('Cannot send a prompt while a shell command is running');
       }
+      // Checked before the streaming-behavior split: a steer of a TUI-only
+      // command is just as meaningless as a fresh one. `streaming` keeps the
+      // refusal from clearing a running turn's flags when the prompt was a
+      // steer aimed at that turn.
+      if (refuseTuiOnlyPrompt(host, command.message, Boolean(command.streamingBehavior))) return null;
       const streamingBehavior = command.streamingBehavior as 'steer' | 'followUp' | undefined;
       // The live `stream` row starts with the DISPATCH, not with agent_start:
       // the spawn/ack round trip that precedes agent_start must not read as
@@ -229,6 +273,7 @@ export async function dispatchSessionCommand(host: SessionCommandHost, command:
       if (!host.isRunning()) {
         throw new WebRpcError('The session is idle — start a prompt first.', 'session_idle');
       }
+      if (refuseTuiOnlyPrompt(host, command.message, true)) return null;
       await host.proc.sendCommand({
         type,
         message: command.message as string,

package/src/server/lib/omp/session/merge-stored-notices.test.ts

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Builtin-command output must survive a reload. omp writes NOTHING to the
+ * session JSONL for a `/context` or `/usage` turn — the output exists only in
+ * the live `command_output` frame — so the chamber's own copy is the only place
+ * it can be kept, and `mergeOmpAttachments` has to splice it back in.
+ *
+ * The anchor is the user turn that produced it, matched by CONTENT: the
+ * chamber's optimistic user row carries a `msg-…-user` id while the JSONL
+ * records omp's timestamp id, so an id match never fires.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { mergeOmpAttachments, type StoredMessage } from '@/server/lib/omp/session/merge-stored';
+
+const CONTEXT_NOTICE = 'Context window: 1000000 tokens (1% used)';
+
+/** What the JSONL yields for a turn whose command wrote no entry. */
+function jsonlTurn(): StoredMessage[] {
+  return [
+    { id: 'omp-user-1', role: 'user', content: '/context' },
+    { id: 'omp-ai-1', role: 'ai', content: 'Done.' },
+  ];
+}
+
+/** The chamber's own copy of that same conversation, plus the notice row. */
+function storedWithNotice(): string {
+  const stored: StoredMessage[] = [
+    { id: 'msg-1-user', role: 'user', content: '/context' },
+    { id: 'cmdout-1', role: 'ai', content: '', notice: CONTEXT_NOTICE },
+    { id: 'omp-ai-1', role: 'ai', content: 'Done.' },
+  ];
+  return JSON.stringify(stored);
+}
+
+describe('mergeOmpAttachments notice restoration', () => {
+  test('splices a stored notice back under its user turn', () => {
+    const merged = mergeOmpAttachments(jsonlTurn(), storedWithNotice());
+
+    expect(merged.map((m) => m.notice ?? m.content)).toEqual([
+      '/context',
+      CONTEXT_NOTICE,
+      'Done.',
+    ]);
+  });
+
+  test('leaves a conversation with no stored notices untouched', () => {
+    const stored = JSON.stringify([{ id: 'msg-1-user', role: 'user', content: '/context' }]);
+    const merged = mergeOmpAttachments(jsonlTurn(), stored);
+    expect(merged.some((m) => m.notice !== undefined)).toBe(false);
+    expect(merged).toHaveLength(2);
+  });
+
+  test('does not duplicate a notice the JSONL itself carried', () => {
+    const messages: StoredMessage[] = [
+      { id: 'omp-user-1', role: 'user', content: 'run it' },
+      { id: 'omp-notice-1', role: 'ai', content: '', notice: CONTEXT_NOTICE },
+    ];
+    const merged = mergeOmpAttachments(messages, storedWithNotice());
+    expect(merged.filter((m) => m.notice === CONTEXT_NOTICE)).toHaveLength(1);
+  });
+
+  test('appends an unanchorable notice instead of dropping it', () => {
+    // The stored user turn has no counterpart in the JSONL at all (omp rewrote
+    // or pruned it), so there is nothing to anchor to — the row must still show.
+    const stored = JSON.stringify([
+      { id: 'msg-x', role: 'user', content: 'a turn the JSONL never recorded' },
+      { id: 'cmdout-x', role: 'ai', content: '', notice: 'Orphan notice' },
+    ]);
+    const merged = mergeOmpAttachments(jsonlTurn(), stored);
+    expect(merged.map((m) => m.notice).filter(Boolean)).toContain('Orphan notice');
+  });
+
+  test('tolerates malformed stored JSON', () => {
+    const merged = mergeOmpAttachments(jsonlTurn(), '{not json');
+    expect(merged).toHaveLength(2);
+  });
+});

package/src/server/lib/omp/session/merge-stored.ts

@@ -42,6 +42,14 @@ export interface StoredMessage {
   date?: string;
   timestamp?: string;
   attachments?: StoredAttachment[];
+  /**
+   * A notice row — omp's own reminder/task-result entries, or the chamber's
+   * rendering of a builtin command's output. The JSONL cannot round-trip
+   * command output at all: a `/context` or `/usage` turn writes no entry to the
+   * session file, so the notice exists ONLY in the live frame, and without this
+   * the row vanished on reload.
+   */
+  notice?: string;
 }
 
 function isRawComposerInput(content: string): boolean {
@@ -158,7 +166,7 @@ export function mergeOmpAttachments(
       byContent.set(m.content, m.attachments);
     }
   }
-  return merged.map((m) => {
+  const merged2 = merged.map((m) => {
     if (m.role !== 'user' || m.attachments?.length) return m;
     // The JSONL content may carry inlined text-file blocks appended to the
     // original prompt, so match by prefix instead of exact equality.
@@ -168,4 +176,65 @@ export function mergeOmpAttachments(
         )?.[1];
     return atts ? { ...m, attachments: atts } : m;
   });
+  return spliceStoredNotices(merged2, stored);
+}
+
+/**
+ * Re-attach notice rows the chamber stored but the JSONL cannot carry.
+ *
+ * A builtin slash command writes NOTHING to the session file — omp answers it
+ * on the command path and the output lives only in the `command_output` frame —
+ * so a `/context` or `/usage` row disappeared on reload, leaving a timeline that
+ * had forgotten a command the user just ran. The chamber's own copy keeps them.
+ *
+ * Placement is by the USER TURN that produced them, never by id: the chamber's
+ * optimistic user row carries a `msg-…-user` id while the JSONL records omp's
+ * own timestamp id, so the two never match. The stored list is walked backwards
+ * to the nearest user message, and that message is located in the merged list
+ * with the same content relation the attachment merge uses (omp rewrites the
+ * delivered prompt, so equality alone would miss it). A notice whose anchor
+ * cannot be resolved is appended at the end rather than dropped — losing it
+ * again is the bug being fixed.
+ */
+function spliceStoredNotices(merged: StoredMessage[], stored: StoredMessage[]): StoredMessage[] {
+  const storedNotices = stored
+    .map((message, index) => ({ message, index }))
+    .filter(({ message }) => message?.role !== 'user' && typeof message?.notice === 'string' && message.notice.trim());
+  if (storedNotices.length === 0) return merged;
+
+  // Already present (a notice the JSONL itself carried, e.g. a task result):
+  // matching on the text keeps the JSONL's own row authoritative.
+  const present = new Set(merged.map((m) => (typeof m.notice === 'string' ? m.notice : '')).filter(Boolean));
+
+  const mergedUsers = merged
+    .map((message, index) => ({ message, index }))
+    .filter(({ message }) => message.role === 'user');
+
+  const insertions = new Map<number, StoredMessage[]>();
+  for (const { message, index } of storedNotices) {
+    if (present.has(message.notice as string)) continue;
+    let anchor = merged.length;
+    for (let i = index - 1; i >= 0; i -= 1) {
+      const candidate = stored[i];
+      if (candidate?.role !== 'user' || typeof candidate.content !== 'string') continue;
+      const hit = mergedUsers.find(({ message: user }) =>
+        user.id !== undefined && candidate.id !== undefined && user.id === candidate.id,
+      ) ?? mergedUsers.find(({ message: user }) => userTurnsRelate(user.content, candidate.content));
+      if (hit) {
+        anchor = hit.index + 1;
+        break;
+      }
+    }
+    const group = insertions.get(anchor);
+    if (group) group.push(message);
+    else insertions.set(anchor, [message]);
+  }
+  if (insertions.size === 0) return merged;
+
+  const next = [...merged];
+  for (const anchor of [...insertions.keys()].sort((a, b) => b - a)) {
+    const group = insertions.get(anchor);
+    if (group) next.splice(anchor, 0, ...group);
+  }
+  return next;
 }

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/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');
+  });
+});