ompchamber 3.3.3 → 3.5.0

package/src/client/hooks/chat/btw/index.ts

@@ -12,11 +12,14 @@
  * merge logic of its own and a reload can never disagree with the server.
  * The stream is attached only while the panel is open: a side question is a
  * deliberate action, not background traffic.
+ *
+ * There are no per-topic pickers here. A side question runs without tools and on
+ * the CHAT's model and thinking selector (the server re-reads them from the
+ * parent transcript at every ask), which is what omp's own `/btw` does.
  */
 
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 import type { AgentImage, Attachment, BtwState, ChatMessageData, StreamTransport } from '@/shared/types';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { attachmentImage, readTextAttachments } from '@/shared/lib/chat/attachments';
 import {
   BtwRequestError,
@@ -26,10 +29,6 @@ import {
   deleteBtwTopic,
   fetchBtwState,
   promoteBtwTopic,
-  respondBtwDialog,
-  setBtwAccessMode,
-  setBtwModel,
-  setBtwThinkingLevel,
 } from '@/shared/lib/chat/btw/client';
 import type { StreamConnection } from '@/shared/lib/chat/omp/transport';
 
@@ -40,7 +39,7 @@ export type BtwImage = AgentImage;
  * The turn streaming right now. `messages` is the turn's conversation in the
  * chat's own shape, upserted by `message.id` exactly as the chat stream does —
  * so the panel renders a live side answer through the same components the chat
- * uses, tool calls included.
+ * uses.
  */
 export interface BtwLiveAnswer {
   topicId: string;
@@ -50,17 +49,6 @@ export interface BtwLiveAnswer {
   activity: string;
 }
 
-/**
- * Composer picks for a topic's FIRST question. A topic that does not exist yet
- * has no row to write them to, so they ride the ask and reach the spawn; later
- * questions address an existing topic through the dedicated setters.
- */
-export interface BtwFirstQuestionPicks {
-  model?: { provider: string; id: string };
-  thinkingLevel?: string;
-  approvalMode?: ApprovalMode;
-}
-
 export interface BtwSessionHandle {
   state: BtwState | null;
   live: BtwLiveAnswer | null;
@@ -69,12 +57,8 @@ export interface BtwSessionHandle {
   busy: boolean;
   /** Resolves with the canonical state the command produced, or null when it
    *  was refused (the reason is then in `error`). */
-  ask: (question: string, attachments?: Attachment[], topicId?: string, picks?: BtwFirstQuestionPicks) => Promise<BtwState | null>;
+  ask: (question: string, attachments?: Attachment[], topicId?: string) => Promise<BtwState | null>;
   abort: (topicId: string) => Promise<void>;
-  setModel: (topicId: string, provider: string, modelId: string) => Promise<void>;
-  setThinkingLevel: (topicId: string, level: string) => Promise<void>;
-  setAccessMode: (topicId: string, mode: ApprovalMode) => Promise<void>;
-  respondToDialog: (topicId: string, id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => Promise<void>;
   /** Returns the new session id to open, or null when it was refused. */
   promote: (topicId: string) => Promise<string | null>;
   remove: (topicId: string) => Promise<void>;
@@ -186,7 +170,6 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
       question: string,
       attachments: Attachment[] = [],
       topicId?: string,
-      picks?: BtwFirstQuestionPicks,
     ): Promise<BtwState | null> => {
       setError(null);
       // Same split the chat send path makes: images travel as provider payloads,
@@ -201,9 +184,6 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
         topicId,
         ...(images.length ? { images } : {}),
         ...(textFiles.length ? { textFiles } : {}),
-        // Only a first question carries picks; a follow-up addresses a topic
-        // that already owns them.
-        ...(topicId ? {} : picks ?? {}),
       }));
       setLive(null);
       if (next && !next.runningTopicId) {
@@ -222,38 +202,6 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
     [run],
   );
 
-  const setModel = useCallback(
-    async (topicId: string, provider: string, modelId: string) => {
-      setError(null);
-      await run((id) => setBtwModel(id, topicId, provider, modelId));
-    },
-    [run],
-  );
-
-  const setThinkingLevel = useCallback(
-    async (topicId: string, level: string) => {
-      setError(null);
-      await run((id) => setBtwThinkingLevel(id, topicId, level));
-    },
-    [run],
-  );
-
-  const setAccessMode = useCallback(
-    async (topicId: string, mode: ApprovalMode) => {
-      setError(null);
-      await run((id) => setBtwAccessMode(id, topicId, mode));
-    },
-    [run],
-  );
-
-  const respondToDialog = useCallback(
-    async (topicId: string, id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => {
-      setError(null);
-      await run((requestId) => respondBtwDialog(requestId, topicId, id, response));
-    },
-    [run],
-  );
-
   const remove = useCallback(
     async (topicId: string) => {
       setError(null);
@@ -283,19 +231,5 @@ export function useBtwSession(sessionId: string | null, options: BtwSessionOptio
 
   const clearError = useCallback(() => setError(null), []);
 
-  return {
-    state,
-    live,
-    error,
-    busy,
-    ask,
-    abort,
-    setModel,
-    setThinkingLevel,
-    setAccessMode,
-    respondToDialog,
-    promote,
-    remove,
-    clearError,
-  };
+  return { state, live, error, busy, ask, abort, promote, remove, clearError };
 }

package/src/client/hooks/chat/btw/intercept.test.ts

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `/btw` interception.
+ *
+ * The token must be recognized the way omp parses a slash invocation — on the
+ * earliest whitespace OR `:` — because a form the chamber does not intercept is
+ * sent to the model as literal text (omp's `/btw` is TUI-only, so nothing
+ * downstream understands it).
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { dispatchBtwCommand } from '@/client/hooks/chat/btw/intercept';
+
+/**
+ * `bun test` runs without a DOM; the interceptor only needs an event target.
+ *
+ * The stub is installed for this file alone and REMOVED afterwards: several
+ * other files in this suite install their own DOM by assigning `globalThis`,
+ * and a `window` left behind here replaced theirs (measured: `use-file-editor`
+ * failed with `form.get is not a function`). The descriptor is `writable` for
+ * the same reason — those files assign rather than define.
+ */
+const hadWindow = Object.getOwnPropertyDescriptor(globalThis, 'window');
+
+beforeAll(() => {
+  Object.defineProperty(globalThis, 'window', { value: new EventTarget(), configurable: true, writable: true });
+});
+
+afterAll(() => {
+  if (hadWindow) Object.defineProperty(globalThis, 'window', hadWindow);
+  else delete (globalThis as Record<string, unknown>).window;
+});
+
+function capture(text: string): { handled: boolean; detail: unknown } {
+  let detail: unknown;
+  const listener = (event: Event) => {
+    detail = (event as CustomEvent).detail;
+  };
+  window.addEventListener('omp:btw', listener);
+  try {
+    const handled = dispatchBtwCommand(text, []);
+    return { handled, detail };
+  } finally {
+    window.removeEventListener('omp:btw', listener);
+  }
+}
+
+describe('dispatchBtwCommand', () => {
+  test('a bare command opens the panel with no question', () => {
+    const { handled, detail } = capture('/btw');
+    expect(handled).toBe(true);
+    expect(detail).toEqual({ question: '' });
+  });
+
+  test('a whitespace-separated question is carried', () => {
+    const { handled, detail } = capture('/btw what is this?');
+    expect(handled).toBe(true);
+    expect(detail).toEqual({ question: 'what is this?' });
+  });
+
+  test('a colon-separated question is the same invocation', () => {
+    const { handled, detail } = capture('/btw:what is this?');
+    expect(handled).toBe(true);
+    expect(detail).toEqual({ question: 'what is this?' });
+  });
+
+  test('case does not matter', () => {
+    expect(capture('/BTW hi').handled).toBe(true);
+  });
+
+  test('anything else is left for the normal send path', () => {
+    expect(capture('hello /btw').handled).toBe(false);
+    expect(capture('/btwx').handled).toBe(false);
+    expect(capture('').handled).toBe(false);
+  });
+});

package/src/client/hooks/chat/btw/intercept.ts

@@ -23,8 +23,11 @@
 import type { Attachment } from '@/shared/types';
 
 /** A bare `/btw` opens the form on the current history; anything after it is
- *  the first question. Case-insensitive, because omp's command tokens are. */
-const BTW_COMMAND_RE = /^\/btw(?:\s+([\s\S]*))?$/i;
+ *  the first question. Case-insensitive, because omp's command tokens are, and
+ *  the separator is whitespace OR `:` — `parseSlashCommand` splits on whichever
+ *  comes first, so `/btw:what is this` is the same invocation as `/btw what is
+ *  this` and must not be sent to the model as text. */
+const BTW_COMMAND_RE = /^\/btw(?:[\s:]+([\s\S]*))?$/i;
 
 /**
  * Hand a `/btw` draft to the side-question panel. Returns false when the text

package/src/client/hooks/chat/btw/mode.ts

@@ -14,28 +14,24 @@
  *
  * `/btw [question]` in the main composer is the entry point; a question that
  * arrived with the command is asked immediately, which is what the TUI does.
+ *
+ * The panel has no model / thinking / access pickers: a side question runs on
+ * the chat's own model and thinking selector and without tools, so a control
+ * here would promise something the child does not read.
  */
 
 import { useCallback, useState } from 'preact/hooks';
-import type { Attachment, BtwDialog, BtwState, BtwTopic, ChatMessageData } from '@/shared/types';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
-import { useBtwSession, type BtwFirstQuestionPicks, type BtwLiveAnswer } from '@/client/hooks/chat/btw';
+import type { Attachment, BtwState, BtwTopic, ChatMessageData } from '@/shared/types';
+import { useBtwSession, type BtwLiveAnswer } from '@/client/hooks/chat/btw';
 import { useChamberEvent } from '@/client/hooks/ui/window-event';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
 import { useSearchParams } from '@/client/lib/router/search-params';
 import { readStreamTransport } from '@/shared/lib/chat/omp/transport';
-import { normalizeApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
-import { readChamberSetting } from '@/shared/lib/settings/client';
 
 /** Question sent when a question arrived carrying only images. */
 const ATTACHMENT_ONLY_QUESTION = 'Describe the attached image.';
 
-/** The composer's persisted access pick, for a topic that has none yet. */
-function readAccessMode(appSettings: Record<string, unknown>): ApprovalMode {
-  return normalizeApprovalMode(readChamberSetting<unknown>('omp_access_mode', appSettings));
-}
-
 export interface BtwMode {
   open: boolean;
   topics: BtwTopic[];
@@ -49,11 +45,6 @@ export interface BtwMode {
   /** What that turn is doing, for the panel's indicator (side stream's own). */
   liveVerb?: string;
   error: string | null;
-  /** Ask/approval dialogs the side child is blocked on, oldest first. */
-  dialogs: BtwDialog[];
-  /** Access mode the active topic's child runs under. */
-  accessMode: ApprovalMode;
-  thinkingLevel: string;
   askDraft: string;
   followUpDraft: string;
   setAskDraft: (value: string) => void;
@@ -68,12 +59,8 @@ export interface BtwMode {
   submitAsk: () => void;
   /** Submit the side session's composer: a follow-up to the active topic. */
   submitFollowUp: (question: string, attachments?: Attachment[]) => void;
-  abort: () => void;
-  /** Re-target the side child's model (applies to the running turn). */
-  setModel: (provider: string, modelId: string) => void;
-  setThinkingLevel: (level: string) => void;
-  setAccessMode: (mode: ApprovalMode) => void;
-  respondToDialog: (id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => void;
+  /** Cancel the running turn, if any. Returns whether one was running. */
+  abort: () => boolean;
   /** Returns the session id to open, or null when promotion was refused. */
   promote: () => Promise<string | null>;
   removeTopic: (topicId: string) => void;
@@ -121,16 +108,6 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
    */
   const liveVerb = live?.activity || (runningTopicId ? PHASE_VERBS.sideQuestion : undefined);
 
-  /**
-   * Composer picks made before a topic exists. They are per-session UI state
-   * rather than props, because the form must show what the FIRST question will
-   * actually run with — the topic that would otherwise own these values has not
-   * been created yet.
-   */
-  const [pendingModel, setPendingModel] = useSessionState<BtwFirstQuestionPicks['model'] | null>('chat.btwModel', null);
-  const [pendingThinking, setPendingThinking] = useSessionState<string>('chat.btwThinking', 'auto');
-  const [pendingAccess, setPendingAccess] = useSessionState<ApprovalMode | null>('chat.btwAccess', null);
-
   const selectNewest = useCallback(
     (next: BtwState | null) => {
       if (!next) return;
@@ -151,27 +128,12 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     }
   });
 
-  /**
-   * What the next FIRST question will run with: the composer's picks until a
-   * topic exists, then that topic's own settings. Every setter below writes to
-   * the topic when there is one and to this pending slot when there is not —
-   * a pick that only reached the UI would silently not apply.
-   */
-  const firstQuestionPicks = useCallback(
-    (): BtwFirstQuestionPicks => ({
-      ...(pendingModel ? { model: pendingModel } : {}),
-      ...(pendingThinking && pendingThinking !== 'auto' ? { thinkingLevel: pendingThinking } : {}),
-      ...(pendingAccess ? { approvalMode: pendingAccess } : {}),
-    }),
-    [pendingModel, pendingThinking, pendingAccess],
-  );
-
   const submitAsk = useCallback(() => {
     const question = askDraft.trim();
     if (!question) return;
     setAskDraft('');
-    void session.ask(question, undefined, undefined, firstQuestionPicks()).then(selectNewest);
-  }, [askDraft, session, setAskDraft, selectNewest, firstQuestionPicks]);
+    void session.ask(question).then(selectNewest);
+  }, [askDraft, session, setAskDraft, selectNewest]);
 
   const submitFollowUp = useCallback(
     (question: string, attachments?: Attachment[]) => {
@@ -220,12 +182,6 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     liveMessages: live ? live.messages : [],
     liveVerb,
     error: session.error,
-    dialogs: session.state?.dialogs ?? [],
-    // Before a topic exists the composer's own picks are what the next question
-    // will run with, so they are what the controls must show — and after it,
-    // the topic's own settings (which the pick was written to).
-    accessMode: activeTopic?.approvalMode ?? pendingAccess ?? readAccessMode(appSettings),
-    thinkingLevel: activeTopic?.thinkingLevel ?? pendingThinking,
     askDraft,
     followUpDraft,
     setAskDraft,
@@ -239,29 +195,13 @@ export function useBtwMode(sessionId: string | null, appSettings: Record<string,
     },
     submitAsk,
     submitFollowUp,
+    // Escape (and the composer's Stop) cancel the turn BEFORE leaving: omp's
+    // Escape handler cancels a running answer and only then closes the panel, so
+    // a stray keypress cannot abandon a question mid-flight.
     abort: () => {
-      if (runningTopicId) void session.abort(runningTopicId);
-    },
-    setModel: (provider: string, modelId: string) => {
-      if (!activeTopic) {
-        setPendingModel({ provider, id: modelId });
-        return;
-      }
-      void session.setModel(activeTopic.id, provider, modelId);
-    },
-    setThinkingLevel: (level: string) => {
-      setPendingThinking(level);
-      if (!activeTopic) return;
-      void session.setThinkingLevel(activeTopic.id, level);
-    },
-    setAccessMode: (mode: ApprovalMode) => {
-      setPendingAccess(mode);
-      if (!activeTopic) return;
-      void session.setAccessMode(activeTopic.id, mode);
-    },
-    respondToDialog: (id: string, response: { value: string } | { confirmed: boolean } | { cancelled: true }) => {
-      if (!activeTopic) return;
-      void session.respondToDialog(activeTopic.id, id, response);
+      if (!runningTopicId) return false;
+      void session.abort(runningTopicId);
+      return true;
     },
     promote,
     removeTopic,

package/src/client/hooks/chat/timeline/actions.ts

@@ -11,13 +11,15 @@
  * record — captured semantics are unchanged.
  */
 
-import { useCallback } from 'preact/hooks';
+import { useCallback, useMemo } from 'preact/hooks';
 import type { Dispatch, SetStateAction } from 'preact/compat';
 import type { Attachment, ChatMessageData, OmpAgentHandle, QueuedMessageModel } from '@/shared/types';
 import type { QueuedMessage } from '@/client/components/workspace/chat-timeline/QueueList';
 import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { applyComposerPick, consumeComposerPick, stashComposerPick, type DeferredModelStore } from '@/client/hooks/chat/timeline/deferred-model';
 import { dispatchBtwCommand } from '@/client/hooks/chat/btw/intercept';
+import { blockTuiOnlySend } from '@/client/hooks/chat/timeline/tui-only-guard';
+import { createQueueActions } from '@/client/hooks/chat/timeline/queue-actions';
 import { prepareQueuedAttachments } from '@/shared/lib/chat/attachments';
 
 export interface ChatTimelineActionsDeps {
@@ -76,14 +78,12 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
   const {
     inputValue,
     setInputValue,
-    setInputAttachments,
     isGenerating,
     isOmpSession,
     sessionId,
     appSettings,
     messageQueue,
     enqueueMessage,
-    removeMessage,
     executeSend,
     steerOmpAgent,
     ompAgent,
@@ -100,6 +100,10 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     setSearchParams,
   } = deps;
 
+  // The queue's two row actions take the same slice of this deps record, so
+  // they are built once per render from it rather than re-listing every field.
+  const queueActions = useMemo(() => createQueueActions(deps), [deps]);
+
   const handleSend = useCallback(async (attachments: Attachment[], options?: { steering?: boolean }) => {
     const textToSend = inputValue.trim();
     if (!textToSend && attachments.length === 0) return;
@@ -111,11 +115,21 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     // `/btw [question]` is the side-question entry point, not chat text: the
     // panel owns it (omp's `/btw` is TUI-only, so nothing downstream would
     // understand the token). A bare `/btw` only opens the panel's history.
+    //
+    // MUST run before the TUI-only guard below: `/btw` is in that table (omp
+    // implements it in the TUI only), so the guard would refuse the very
+    // command the chamber answers with a panel.
     if (dispatchBtwCommand(textToSend, attachments)) {
       setInputValue('');
       return;
     }
 
+    // A command omp only implements in its TUI (`/plan`, `/clear`, `/login`, …)
+    // would reach the model as literal text over RPC and burn a whole turn on
+    // an improvisation. Answer it here, before it is queued or steered, and
+    // keep the draft so the user can edit or retype it.
+    if (blockTuiOnlySend(textToSend, setLocalMessages)) return;
+
     if (isGenerating) {
       if (options?.steering) {
         // Explicit steering while a run is active.
@@ -161,37 +175,15 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
 
     setInputValue('');
     executeSend(textToSend, attachments);
-  }, [inputValue, isGenerating, executeSend, enqueueMessage, isOmpSession, appSettings, steerOmpAgent, setInputValue, abortControllerRef, setGenerating, stopHoldRef, composerModelRef, accessModeRef]);
+  }, [inputValue, isGenerating, executeSend, enqueueMessage, isOmpSession, appSettings, steerOmpAgent, setInputValue, abortControllerRef, setGenerating, stopHoldRef, composerModelRef, accessModeRef, setLocalMessages]);
 
   const handleEditQueueItem = useCallback((item: QueuedMessage) => {
-    // Lift the text into the composer and drop the row. If the user never
-    // re-submits, the delete (below) already removed it — the old flow had a
-    // dead window here where removing from the local list was the only edit.
-    setInputValue(item.text);
-    setInputAttachments(item.attachments);
-    removeMessage(item.id);
-  }, [removeMessage, setInputValue, setInputAttachments]);
+    queueActions.handleEditQueueItem(item);
+  }, [queueActions]);
 
   const handleSendNowQueueItem = useCallback(async (item: QueuedMessage) => {
-    // Explicit delivery also lifts the Stop hold (mock path).
-    stopHoldRef.current = false;
-    removeMessage(item.id);
-
-    if (isGenerating) {
-      if (isOmpSession) {
-        void steerOmpAgent(item.text, item.attachments);
-      } else {
-        if (abortControllerRef.current) {
-          abortControllerRef.current.abort();
-          abortControllerRef.current = null;
-        }
-        setGenerating(false);
-        setTimeout(() => executeSend(item.text, item.attachments, { model: item.model }), 0);
-      }
-    } else {
-      executeSend(item.text, item.attachments, { model: item.model });
-    }
-  }, [isGenerating, executeSend, removeMessage, isOmpSession, steerOmpAgent, abortControllerRef, setGenerating, stopHoldRef]);
+    await queueActions.handleSendNowQueueItem(item);
+  }, [queueActions]);
 
   const handleUndo = useCallback(async (msgId: string, content?: string): Promise<boolean> => {
     if (isGenerating) {

package/src/client/hooks/chat/timeline/queue-actions.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Queue-row actions for the chat timeline: editing a queued item back into the
+ * composer, and delivering one immediately.
+ *
+ * Split out of `actions.ts` so that hook keeps to the repo's per-file ceiling.
+ * Both handlers take the same deps record, and both are about ONE row of the
+ * follow-up queue rather than about the composer's own send path — which is the
+ * seam this file draws.
+ */
+
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { Attachment, QueuedMessageModel } from '@/shared/types';
+import type { QueuedMessage } from '@/client/components/workspace/chat-timeline/QueueList';
+
+export interface QueueActionsDeps {
+  setInputValue: (v: string) => void;
+  setInputAttachments: Dispatch<SetStateAction<Attachment[]>>;
+  removeMessage: (id: string) => void;
+  /** Armed by Stop; the queue auto-process holds off while it is set. */
+  stopHoldRef: { current: boolean };
+  isGenerating: boolean;
+  isOmpSession: boolean;
+  steerOmpAgent: (text: string, attachments: Attachment[]) => Promise<void>;
+  abortControllerRef: { current: AbortController | null };
+  setGenerating: (v: boolean) => void;
+  executeSend: (
+    text: string,
+    attachments: Attachment[],
+    options?: { model?: QueuedMessageModel | null },
+  ) => Promise<void>;
+}
+
+export interface QueueActions {
+  handleEditQueueItem: (item: QueuedMessage) => void;
+  handleSendNowQueueItem: (item: QueuedMessage) => Promise<void>;
+}
+
+export function createQueueActions(deps: QueueActionsDeps): QueueActions {
+  const {
+    setInputValue,
+    setInputAttachments,
+    removeMessage,
+    stopHoldRef,
+    isGenerating,
+    isOmpSession,
+    steerOmpAgent,
+    abortControllerRef,
+    setGenerating,
+    executeSend,
+  } = deps;
+  return {
+    /** Lift the row's text into the composer and drop the row. If the user
+     *  never re-submits, the delete already removed it — the old flow had a
+     *  dead window here where removing from the local list was the only edit. */
+    handleEditQueueItem: (item) => {
+      setInputValue(item.text);
+      setInputAttachments(item.attachments);
+      removeMessage(item.id);
+    },
+
+    /** Deliver one row now, ahead of the queue. Explicit delivery also lifts
+     *  the Stop hold, so the auto-process may resume after this run ends. */
+    handleSendNowQueueItem: async (item) => {
+      stopHoldRef.current = false;
+      removeMessage(item.id);
+
+      if (isGenerating) {
+        if (isOmpSession) {
+          void steerOmpAgent(item.text, item.attachments);
+        } else {
+          if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            abortControllerRef.current = null;
+          }
+          setGenerating(false);
+          setTimeout(() => executeSend(item.text, item.attachments, { model: item.model }), 0);
+        }
+      } else {
+        executeSend(item.text, item.attachments, { model: item.model });
+      }
+    },
+  };
+}

package/src/client/hooks/chat/timeline/send.ts

@@ -26,6 +26,7 @@ import {
   readTextAttachments,
 } from '@/shared/lib/chat/attachments';
 import { createMockStreamCallbacks } from '@/shared/lib/chat/timeline/stream-callbacks';
+import { blockTuiOnlySend } from '@/client/hooks/chat/timeline/tui-only-guard';
 import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
 import { formatClock } from '@/shared/lib/format/time';
 
@@ -135,6 +136,12 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
     attachments: Attachment[],
     options?: { model?: QueuedMessageModel | null },
   ) => {
+    // Last gate before a prompt leaves the client. `handleSend` already refuses
+    // these, but `executeSend` is also reached by a retry of a stored turn, a
+    // queued item's "Send now", and `submitNewChat` — all of which can carry a
+    // command that was typed before the guard existed, or that arrived from the
+    // queue. Nothing has been rendered yet, so no rollback is needed.
+    if (blockTuiOnlySend(text, setLocalMessages)) return;
     // A queued delivery replays the snapshot the item was queued with; a plain
     // send keeps the session's live picks. 'auto' thinking leaves omp alone.
     const modelOverride = options?.model ?? null;
@@ -304,6 +311,6 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
         scrollToBottom,
       })
     );
-  }, [appSettings, folders, isOmpSession, ompAgent, selectedFolderId, sessionId, scrollToBottom, jumpToBottom, persistMessages, seedSession, pendingComposerModelRef, pendingThinkingLevelRef, deferredComposerPickRef, accessModeRef]);
+  }, [appSettings, folders, isOmpSession, ompAgent, selectedFolderId, sessionId, scrollToBottom, jumpToBottom, persistMessages, seedSession, pendingComposerModelRef, pendingThinkingLevelRef, deferredComposerPickRef, accessModeRef, setLocalMessages]);
   return { steerOmpAgent, executeSend };
 }

package/src/client/hooks/chat/timeline/tui-only-guard.ts

@@ -0,0 +1,58 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Refuse a slash command omp only implements in its own TUI, in the composer,
+ * before it can cost a turn.
+ *
+ * The guard exists because the RPC prompt path has no slash handling for these
+ * names: `session.prompt()` only expands file commands and prompt templates, so
+ * `/plan` arrives at the model as literal text and it improvises a whole turn
+ * around the string (measured: `/hotkeys` sent the model to read omp's own docs
+ * and run bash). The composer already knows the token, so it answers locally
+ * with the same notice row shape a real `command_output` frame produces — the
+ * user sees why nothing ran, and the model never sees the command.
+ *
+ * Every send path funnels through here: a fresh send, a steer, a retry of a
+ * stored turn, and a queued item's "send now". Queued auto-delivery is covered
+ * server-side (`blockedSlashPrompt` in the RPC dispatcher), because it never
+ * passes through this module.
+ */
+
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { ChatMessageData } from '@/shared/types';
+import { isTuiOnlySlashCommand, tuiOnlyCommandNotice } from '@/shared/lib/chat/composer/tui-only';
+
+/**
+ * Append the refusal as a notice row, the same shape `onCommandOutput` builds.
+ * Placed at the tail: no AI placeholder exists yet, so there is nothing to
+ * insert before.
+ */
+export function appendTuiOnlyNotice(
+  text: string,
+  setLocalMessages: Dispatch<SetStateAction<ChatMessageData[]>>,
+): void {
+  const row: ChatMessageData = {
+    id: `tui-only-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    role: 'ai',
+    content: '',
+    notice: tuiOnlyCommandNotice(text),
+  };
+  setLocalMessages(prev => (prev.some(m => m.notice === row.notice) ? prev : [...prev, row]));
+}
+
+/**
+ * Whether the draft is a TUI-only command and was answered locally. A true
+ * result means the caller must stop — nothing was sent, and the draft is left
+ * in the composer so the user can edit or retype it.
+ */
+export function blockTuiOnlySend(
+  text: string,
+  setLocalMessages: Dispatch<SetStateAction<ChatMessageData[]>>,
+): boolean {
+  if (!isTuiOnlySlashCommand(text)) return false;
+  appendTuiOnlyNotice(text, setLocalMessages);
+  return true;
+}