ompchamber 0.8.0 → 1.1.0

package/src/client/components/workspace/terminal-panel/mount.ts

@@ -0,0 +1,275 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Mounts an xterm instance on a container and keeps it bound to a PTY.
+ *
+ * Extracted from the view component so the mount lifecycle (xterm import, fit
+ * addon, input wiring, observers) stays readable and the component remains a
+ * render layer. Everything the caller must know travels through `callbacks`;
+ * the returned handle is the only way back in.
+ *
+ * Two behaviours here are deliberate:
+ *
+ * - **Attach waits for a real grid.** The terminal panel stays mounted while
+ *   its view is CSS-hidden (that is what keeps a shell alive across panel
+ *   switches), and a hidden container measures 0px — fitting is skipped and
+ *   xterm keeps its 80x24 default. Attaching then would create the shell at a
+ *   size the panel never had, and the retained scrollback would replay at that
+ *   width forever. So attach is driven by the same ResizeObserver that detects
+ *   the panel becoming visible.
+ * - **Raw bytes in, raw bytes out.** `onData`/`onBinary` forward keystrokes
+ *   untouched, and `write` takes a `Uint8Array` so xterm's streaming UTF-8
+ *   decoder reassembles a character split across two PTY reads.
+ * - **xterm and the WebGL addon are dynamically imported on purpose.** xterm is
+ *   ~300 KB and the addon pulls a WebGL context into the panel; both stay out
+ *   of the initial client bundle until the terminal panel is actually opened.
+ *   The module shape varies by build, hence the probe pattern below.
+ */
+
+import type { Terminal } from '@xterm/xterm';
+import type { FitAddon } from '@xterm/addon-fit';
+import type { WebglAddon } from '@xterm/addon-webgl';
+import {
+  getXtermTheme,
+  XTERM_FONT_FAMILY,
+  safePatchFitAddon,
+  safePatchRenderService,
+  type XtermCore,
+  type XtermModule,
+} from '@/client/data/theme/terminal';
+
+export interface XtermMountCallbacks {
+  /** Keystrokes, paste, mouse reports — straight to the PTY. */
+  onInput: (data: string) => void;
+  /** Non-UTF-8 payloads xterm reports separately (some mouse reports). */
+  onBinaryInput: (data: string) => void;
+  /** The grid changed; the PTY must be resized to match. */
+  onGridChange: (cols: number, rows: number) => void;
+  /** The terminal is measurable and knows its size; attach with these. */
+  onReady: (cols: number, rows: number) => void;
+  /** Viewport scrolled away from the live bottom. */
+  onScrolledUpChange: (scrolledUp: boolean) => void;
+}
+
+export interface XtermMount {
+  term: Terminal;
+  fitAddon: FitAddon;
+  /**
+   * Lay the retained scrollback out at the size it was drawn for, then fit the
+   * panel. Grid reports are suppressed until the replay has been consumed.
+   */
+  writeReplay: (bytes: Uint8Array, cols: number, rows: number) => void;
+  dispose: () => void;
+}
+
+/**
+ * Mount xterm inside `container`. Resolves to null when the module could not be
+ * loaded or the component unmounted while importing.
+ */
+export async function mountXterm(
+  container: HTMLElement,
+  isDark: boolean,
+  callbacks: XtermMountCallbacks,
+  isCancelled: () => boolean,
+): Promise<XtermMount | null> {
+  // Dynamic on purpose: xterm is ~300 KB and is only needed once the terminal
+  // panel is actually opened, so it stays out of the initial client bundle
+  // (the module shape varies by build, hence the probes).
+  const xtermModule = (await import('@xterm/xterm')) as unknown as XtermModule<typeof Terminal>;
+  const fitModule = (await import('@xterm/addon-fit')) as unknown as XtermModule<typeof FitAddon>;
+
+  const TerminalClass = xtermModule.Terminal || xtermModule.default?.Terminal || xtermModule.default;
+  const FitAddonClass = fitModule.FitAddon || fitModule.default?.FitAddon || fitModule.default;
+  if (!TerminalClass || !FitAddonClass || isCancelled()) return null;
+
+  safePatchFitAddon(FitAddonClass);
+
+  const term = new TerminalClass({
+    cursorBlink: true,
+    cursorStyle: 'block',
+    fontSize: 12,
+    lineHeight: 1.25,
+    fontFamily: XTERM_FONT_FAMILY,
+    theme: getXtermTheme(isDark),
+    // No `convertEol`: the PTY already emits CRLF, and converting a lone LF
+    // would re-introduce the line-feed doubling a real terminal avoids.
+    scrollback: 10000,
+    scrollSensitivity: 1.5,
+    fastScrollSensitivity: 5,
+    smoothScrollDuration: 0,
+    allowProposedApi: true,
+  }) as Terminal;
+
+  term.open(container);
+  safePatchRenderService(term);
+
+  // WebGL renderer: draws powerline glyphs (U+E0B0 etc.) as full-cell vector
+  // paths, so segmented prompts stay seamless the way a local terminal does.
+  // The DOM renderer draws them as ordinary glyphs inside the font box, which
+  // leaves notches at every segment joint. WebGL can fail (no GPU context,
+  // context-lost), and the DOM renderer is the automatic fallback.
+  try {
+    const webglModule = (await import('@xterm/addon-webgl')) as unknown as {
+      WebglAddon?: typeof WebglAddon;
+      default?: { WebglAddon?: typeof WebglAddon } & typeof WebglAddon;
+    };
+    const WebglAddonClass = webglModule.WebglAddon || webglModule.default?.WebglAddon || webglModule.default;
+    if (WebglAddonClass) {
+      const webgl = new WebglAddonClass() as WebglAddon;
+      webgl.onContextLoss(() => webgl.dispose());
+      term.loadAddon(webgl);
+    }
+  } catch {}
+
+  const fitAddon = new FitAddonClass() as FitAddon;
+  term.loadAddon(fitAddon);
+
+  term.attachCustomKeyEventHandler((event: globalThis.KeyboardEvent) => handleKeyNavigation(term, event));
+
+  const disposables = [
+    term.onScroll(() => {
+      const buffer = term.buffer.active;
+      callbacks.onScrolledUpChange(buffer.viewportY < buffer.baseY);
+    }),
+    term.onData((data: string) => callbacks.onInput(data)),
+    term.onBinary((data: string) => callbacks.onBinaryInput(data)),
+    // FitAddon changes the grid on fit; the shell has to hear about it or a TUI
+    // keeps drawing at the old width. Reports are dropped while the replay is
+    // being laid out: that grid belongs to the recorded history, not the panel.
+    term.onResize(({ cols, rows }) => {
+      if (replaying) return;
+      callbacks.onGridChange(cols, rows);
+    }),
+  ];
+
+  let attached = false;
+  let fitTimer: ReturnType<typeof setTimeout> | null = null;
+  let frame: number | null = null;
+  /**
+   * Set while the retained scrollback is being laid out at its recorded size.
+   * That transient grid is not the panel's, so it must not be reported as a
+   * resize — the shell would answer with a prompt repaint for a size the user
+   * never chose, which is how a reattach used to print a second prompt.
+   */
+  let replaying = false;
+
+  const safeFit = () => {
+    if (isCancelled()) return;
+    if (container.clientWidth <= 0 || container.clientHeight <= 0) return;
+    const core = (term as unknown as XtermCore)._core;
+    const dims = core?._renderService?.dimensions;
+    if (!dims?.css?.cell?.width || !dims?.css?.cell?.height) return;
+    try {
+      fitAddon.fit();
+    } catch {}
+  };
+
+  /** Fit now, once xterm has consumed everything already queued. */
+  const fitAfterWrites = () => {
+    term.write('', () => {
+      if (isCancelled()) return;
+      replaying = false;
+      safeFit();
+    });
+  };
+
+  /**
+   * Lay the retained scrollback out at the size it was drawn for, then converge
+   * on the panel's grid. Re-wrapping history at another width leaves wrapped
+   * fragments the shell's own redraw never clears.
+   */
+  const writeReplay = (bytes: Uint8Array, cols: number, rows: number) => {
+    replaying = true;
+    if (term.cols !== cols || term.rows !== rows) term.resize(cols, rows);
+    if (bytes.length === 0) {
+      fitAfterWrites();
+      return;
+    }
+    term.write(bytes, fitAfterWrites);
+  };
+
+  const attachIfSized = () => {
+    if (attached || isCancelled()) return;
+    if (container.clientWidth <= 0 || container.clientHeight <= 0) return;
+    const core = (term as unknown as XtermCore)._core;
+    if (!core?._renderService?.dimensions?.css?.cell?.width) return;
+    attached = true;
+    callbacks.onReady(term.cols, term.rows);
+    term.focus();
+  };
+
+  const resizeObserver = new ResizeObserver(() => {
+    if (fitTimer) clearTimeout(fitTimer);
+    fitTimer = setTimeout(() => {
+      safeFit();
+      // A panel that was hidden at mount becomes measurable here, which is when
+      // the shell should be created — at its real size.
+      attachIfSized();
+    }, 35);
+  });
+  resizeObserver.observe(container);
+
+  const touch = attachTouchScroll(container, term);
+
+  // The container may already be measurable (the view was active at mount), in
+  // which case the observer never fires a first time.
+  frame = requestAnimationFrame(() => {
+    safeFit();
+    attachIfSized();
+  });
+
+  return {
+    term,
+    fitAddon,
+    writeReplay,
+    dispose() {
+      if (frame !== null) cancelAnimationFrame(frame);
+      clearTimeout(fitTimer ?? undefined);
+      touch();
+      for (const disposable of disposables) disposable.dispose();
+      resizeObserver.disconnect();
+      try {
+        fitAddon.dispose();
+      } catch {}
+      try {
+        term.dispose();
+      } catch {}
+    },
+  };
+}
+
+/** Shift+PageUp/Home/End scroll the viewport instead of reaching the shell. */
+function handleKeyNavigation(term: Terminal, event: globalThis.KeyboardEvent): boolean {
+  if (event.type !== 'keydown' || !event.shiftKey) return true;
+  if (event.key === 'PageUp') { term.scrollPages(-1); return false; }
+  if (event.key === 'PageDown') { term.scrollPages(1); return false; }
+  if (event.key === 'Home') { term.scrollToTop(); return false; }
+  if (event.key === 'End') { term.scrollToBottom(); return false; }
+  if (event.key === 'ArrowUp') { term.scrollLines(-1); return false; }
+  if (event.key === 'ArrowDown') { term.scrollLines(1); return false; }
+  return true;
+}
+
+/** Touch drags scroll the scrollback; xterm has no touch handling of its own. */
+function attachTouchScroll(container: HTMLElement, term: Terminal): () => void {
+  let startY = 0;
+  const onStart = (event: globalThis.TouchEvent) => {
+    if (event.touches.length === 1) startY = event.touches[0].clientY;
+  };
+  const onMove = (event: globalThis.TouchEvent) => {
+    if (event.touches.length !== 1) return;
+    const deltaY = startY - event.touches[0].clientY;
+    if (Math.abs(deltaY) < 16) return;
+    term.scrollLines(Math.trunc(deltaY / 16));
+    startY = event.touches[0].clientY;
+  };
+  container.addEventListener('touchstart', onStart, { passive: true });
+  container.addEventListener('touchmove', onMove, { passive: true });
+  return () => {
+    container.removeEventListener('touchstart', onStart);
+    container.removeEventListener('touchmove', onMove);
+  };
+}

package/src/client/data/theme/terminal.ts

@@ -54,7 +54,33 @@ export function getXtermTheme(isDark: boolean) {
 
 export const XTERM_THEME = XTERM_DARK_THEME;
 
-export const XTERM_FONT_FAMILY = "'Fira Code', Menlo, Monaco, 'Courier New', monospace";
+/**
+ * Font stack for the terminal canvas.
+ *
+ * The glyph fallbacks after the text faces are load-bearing. A shell prompt is
+ * usually drawn with private-use symbols (powerline separators, devicons,
+ * Material Design icons) that **no** coding webfont contains — `@fontsource/
+ * fira-code`'s latin subset maps 226 codepoints and not one of them is above
+ * U+FFFF — so without a face that supplies them the browser paints a hollow
+ * tofu box for every prompt segment. The names below cover the Nerd Font
+ * families a user is most likely to have installed (plus the *fontconfig*
+ * symbol faces on Linux); a face that is absent is simply skipped by the
+ * normal fallback chain, so listing many costs nothing.
+ *
+ * This is the same shape OpenChamber ships (`TERMINAL_GLYPH_FALLBACKS` in its
+ * `ghostty/surface.ts`), which additionally bundles `SymbolsNerdFontMono` as a
+ * webfont so the coverage never depends on the machine.
+ *
+ * Only glyphs the text face lacks reach these entries, so Latin metrics are
+ * untouched — verified: `A`/`m`/`W` keep identical advance and ink.
+ */
+export const XTERM_GLYPH_FALLBACKS =
+  "'FiraCode Nerd Font Mono', 'FiraCode Nerd Font', 'JetBrainsMono Nerd Font', " +
+  "'JetBrainsMono NF', 'JetBrains Mono Nerd Font', 'Hack Nerd Font', 'MesloLGS NF', " +
+  "'MesloLGM Nerd Font', 'CaskaydiaCove Nerd Font', 'SauceCodePro Nerd Font', " +
+  "'Symbols Nerd Font Mono', 'Symbols Nerd Font', 'PowerlineSymbols'";
+
+export const XTERM_FONT_FAMILY = `'Fira Code', ${XTERM_GLYPH_FALLBACKS}, Menlo, Monaco, 'Courier New', monospace`;
 
 /** xterm's private render service, read only to size-check before fitting. */
 export interface XtermCore {
@@ -120,31 +146,3 @@ export function safePatchRenderService(term: any) {
     }
   } catch {}
 }
-
-let terminalSessionOutput = '';
-
-export function getTerminalSessionOutput(): string {
-  return terminalSessionOutput;
-}
-
-export function appendTerminalSessionOutput(chunk: string): void {
-  terminalSessionOutput += chunk;
-  if (terminalSessionOutput.length > 250000) {
-    terminalSessionOutput = terminalSessionOutput.slice(-200000);
-  }
-}
-
-export function clearTerminalSessionOutput(): void {
-  terminalSessionOutput = '';
-}
-
-const TERMINAL_OUTPUT_SNAPSHOT_LIMIT = 8000;
-
-export function getTerminalOutputSnapshot(): string {
-  if (terminalSessionOutput.length <= TERMINAL_OUTPUT_SNAPSHOT_LIMIT) return terminalSessionOutput;
-  return terminalSessionOutput.slice(-TERMINAL_OUTPUT_SNAPSHOT_LIMIT);
-}
-
-export function setTerminalOutputSnapshot(value: string): void {
-  terminalSessionOutput = value;
-}

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

@@ -42,7 +42,18 @@ function isComposingInput(native: Event): boolean {
   );
 }
 
-/** Orchestrates the composer `@`-agent / `/`-command autocomplete flow. */
+/**
+ * Whether the popup may open for this trigger. oh-my-pi only shows the command
+ * popup once the slash token has a real match — a bare `/`, a `/tmp/fo` path,
+ * or a completed `/retry ` must not cover the composer with an empty list.
+ * Mentions keep their own rule: the empty state tells the user what `@` accepts.
+ */
+function shouldOpen(trigger: ComposerTrigger | null, matches: ComposerMatchItem[]): boolean {
+  if (!trigger) return false;
+  return trigger.kind === 'mention' || matches.length > 0;
+}
+
+/** Orchestrates the composer `@`-mention / `/`-command autocomplete flow. */
 export function useComposerTrigger(options: UseComposerTriggerOptions): ComposerTriggerController {
   const { value, setValue, textareaRef, disabled = false, rootPath } = options;
 
@@ -54,8 +65,8 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
   const { items, loading, error } = useComposerItems(trigger?.kind ?? null, rootPath ?? null);
 
   const matches = useMemo(
-    () => filterComposerItems(items, trigger?.query ?? ''),
-    [items, trigger?.query],
+    () => (trigger ? filterComposerItems(items, trigger) : []),
+    [items, trigger],
   );
 
   const clampedIndex = matches.length > 0
@@ -66,6 +77,8 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
 
   const optionId = useCallback((index: number) => `${listboxId}-option-${index}`, [listboxId]);
 
+  const open = shouldOpen(trigger, matches);
+
   const close = useCallback(() => {
     setTrigger(null);
     setActiveIndexState(0);
@@ -112,15 +125,22 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
       const next = insertToken(value, trigger, tokenForItem(item));
       pendingCaretRef.current = next.caret;
       setValue(next.value);
-      close();
+      // Re-query instead of closing: oh-my-pi reopens on the accepted text, so
+      // `/fast` → `/fast ` immediately offers its subcommands and the collapsed
+      // `/skill:` row expands into the individual skills. `shouldOpen` keeps a
+      // completed command from leaving an empty popup behind.
+      setTrigger(detectComposerTrigger(next.value, next.caret));
+      setActiveIndexState(0);
     },
-    [value, trigger, setValue, close],
+    [value, trigger, setValue],
   );
 
   const handleKeyDown = useCallback(
     (e: TargetedKeyboardEvent<HTMLTextAreaElement>): boolean => {
       if (composingRef.current || e.keyCode === 229) return false;
-      if (!trigger) return false;
+      // A closed popup owns nothing: `/tmp/fo` must keep Enter/Tab meaning send
+      // and indent rather than being swallowed by an invisible list.
+      if (!trigger || !open) return false;
 
       if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
         e.preventDefault();
@@ -147,7 +167,7 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
 
       return false;
     },
-    [trigger, matches, clampedIndex, selectItem, close],
+    [trigger, open, matches, clampedIndex, selectItem, close],
   );
 
   useLayoutEffect(() => {
@@ -163,7 +183,7 @@ export function useComposerTrigger(options: UseComposerTriggerOptions): Composer
 
   return {
     trigger,
-    isOpen: trigger !== null,
+    isOpen: open,
     matches,
     loading,
     error,

package/src/client/hooks/chat/omp/session-list.tsx

@@ -116,11 +116,28 @@ export function SidebarDataProvider({ children, initialFolders = [] }: { childre
   const value = useMemo<SidebarDataHandle>(() => {
     const data = fetcher.data;
     const seen = seenRef.current;
+    // A session that streams again earns a fresh badge lifecycle: forget the
+    // ack from an earlier run. Without this, a session opened with a terminal
+    // badge stays stripped for the whole mount — its spinner never renders no
+    // matter how many times the list refetches, and only a page reload (fresh
+    // mount) brings it back.
+    if (seen.size && data?.folders) {
+      for (const folder of data.folders) {
+        for (const session of folder.sessions ?? []) {
+          if (session.streamStatus === 'stream') seen.delete(String(session.id));
+        }
+      }
+    }
     return {
       folders: ((data?.folders ?? initialFolders) as WorkspaceFolderData[])
-        // Optimistic badge strip for sessions marked seen this mount.
+        // Optimistic badge strip for sessions marked seen this mount. NEVER
+        // strip a live `stream` row — the spinner must always render.
         .map((f) => seen.size
-          ? { ...f, sessions: (f.sessions ?? []).map((s) => (seen.has(String(s.id)) ? { ...s, streamStatus: undefined } : s)) }
+          ? { ...f, sessions: (f.sessions ?? []).map((s) => (
+              seen.has(String(s.id)) && s.streamStatus && s.streamStatus !== 'stream'
+                ? { ...s, streamStatus: undefined }
+                : s
+            )) }
           : f),
       isMock: data?.isMock ?? false,
       initializing: !hasLoaded,

package/src/client/hooks/chat/omp/session-sidebar-controller.ts

@@ -62,7 +62,7 @@ export interface SessionSidebarController {
   sortOption: SessionSortOption;
   handleSortChange: (opt: SessionSortOption) => void;
   processedFolders: WorkspaceFolderData[];
-  sessionStatus: Record<string, 'stream' | 'finish' | 'abort' | 'error'>;
+  sessionStatus: Record<string, 'stream' | 'finish' | 'abort'>;
   handleSelectSession: (id: number | string) => void;
 }
 

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

@@ -16,6 +16,7 @@ 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';
 
 export interface ChatTimelineActionsDeps {
   inputValue: string;
@@ -28,7 +29,9 @@ export interface ChatTimelineActionsDeps {
   sessionId: string | null;
   appSettings: Record<string, any>;
   messageQueue: QueuedMessage[];
-  setMessageQueue: (updater: SetStateAction<QueuedMessage[]>) => void;
+  /** Server-backed per-item queue ops (append/remove/reorder). */
+  enqueueMessage: (item: Omit<QueuedMessage, 'id'>) => void;
+  removeMessage: (id: string) => void;
   executeSend: (text: string, attachments: Attachment[], options?: { model?: QueuedMessageModel | null }) => Promise<void>;
   steerOmpAgent: (text: string, attachments: Attachment[]) => Promise<void>;
   ompAgent: OmpAgentHandle;
@@ -46,6 +49,9 @@ export interface ChatTimelineActionsDeps {
   /** Live composer model/thinking mirror, snapshotted onto queued items so
    *  auto-delivery replays the exact settings. */
   composerModelRef: { current: { provider: string; modelId: string; thinkingLevel: string } | null };
+  /** Picks made while a turn streams: held back so they cannot re-target the
+   *  in-flight answer, then pushed onto the session before the next prompt. */
+  deferredComposerPickRef: DeferredModelStore;
   /** Global access-control mode, snapshotted onto queued items. */
   accessModeRef: { current: ApprovalMode };
   setSearchParams: (fn: (prev: URLSearchParams) => URLSearchParams, opts?: { replace?: boolean }) => void;
@@ -74,7 +80,8 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     sessionId,
     appSettings,
     messageQueue,
-    setMessageQueue,
+    enqueueMessage,
+    removeMessage,
     executeSend,
     steerOmpAgent,
     ompAgent,
@@ -86,6 +93,7 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     pendingComposerModelRef,
     pendingThinkingLevelRef,
     composerModelRef,
+    deferredComposerPickRef,
     accessModeRef,
     setSearchParams,
   } = deps;
@@ -123,41 +131,36 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
         return;
       }
       const composerPick = composerModelRef.current;
-      const queuedItem: QueuedMessage = {
-        id: `queue-${Date.now()}`,
-        text: textToSend,
-        attachments,
-        // Snapshot the composer's model/thinking plus the live access mode so
-        // auto-delivery runs the item with exactly these settings.
-        model: composerPick
-          ? { ...composerPick, accessMode: accessModeRef.current }
-          : null,
-      };
-      // Both modes: hold the follow-up in the client queue. The panel is the
-      // source of truth (editable, removable, survives reload via the
-      // session-state blob); delivery happens when the run ends — the
-      // auto-process effect sends the head item. For omp this replaces the
-      // old immediate `follow_up` RPC, whose server-side queue the client
-      // could never cancel (Stop kept executing it).
+      // Snapshot the composer's model/thinking plus the live access mode so
+      // server-side auto-delivery runs the item with exactly these settings.
+      const model = composerPick
+        ? { ...composerPick, accessMode: accessModeRef.current }
+        : null;
+      // Both modes: the item is stored server-side (`queued_messages`) and the
+      // panel is a view of it. Delivery happens when the run ends — the
+      // wrapper's terminal `agent_end` claims the head and dispatches it.
       setInputValue('');
-      setMessageQueue(prev => [...prev, queuedItem]);
+      enqueueMessage({ text: textToSend, attachments, model });
       return;
     }
 
     setInputValue('');
     executeSend(textToSend, attachments);
-  }, [inputValue, isGenerating, executeSend, setMessageQueue, isOmpSession, appSettings, steerOmpAgent, setInputValue, abortControllerRef, setGenerating, stopHoldRef, composerModelRef, accessModeRef]);
+  }, [inputValue, isGenerating, executeSend, enqueueMessage, isOmpSession, appSettings, steerOmpAgent, setInputValue, abortControllerRef, setGenerating, stopHoldRef, composerModelRef, accessModeRef]);
 
   const handleEditQueueItem = useCallback((item: QueuedMessage) => {
-    setMessageQueue(q => q.filter(i => i.id !== item.id));
+    // 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);
-  }, [setMessageQueue, setInputValue, setInputAttachments]);
+    removeMessage(item.id);
+  }, [removeMessage, setInputValue, setInputAttachments]);
 
   const handleSendNowQueueItem = useCallback(async (item: QueuedMessage) => {
-    // Explicit delivery also lifts the Stop hold.
+    // Explicit delivery also lifts the Stop hold (mock path).
     stopHoldRef.current = false;
-    setMessageQueue(q => q.filter(i => i.id !== item.id));
+    removeMessage(item.id);
 
     if (isGenerating) {
       if (isOmpSession) {
@@ -173,7 +176,7 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     } else {
       executeSend(item.text, item.attachments, { model: item.model });
     }
-  }, [isGenerating, executeSend, setMessageQueue, isOmpSession, steerOmpAgent, abortControllerRef, setGenerating, stopHoldRef]);
+  }, [isGenerating, executeSend, removeMessage, isOmpSession, steerOmpAgent, abortControllerRef, setGenerating, stopHoldRef]);
 
   const handleUndo = useCallback(async (msgId: string, content?: string): Promise<boolean> => {
     if (isGenerating) {
@@ -287,16 +290,32 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
       pendingThinkingLevelRef.current = level;
       return;
     }
+    // A pick made mid-run is intent for the NEXT prompt: pushing it now would
+    // re-target the turn already streaming (omp applies set_thinking_level to
+    // the running turn's next LLM call).
+    if (isGenerating) {
+      stashComposerPick(deferredComposerPickRef, { thinkingLevel: level });
+      return;
+    }
+    consumeComposerPick(deferredComposerPickRef, { thinkingLevel: level });
     void ompAgent.setThinkingLevel(level);
-  }, [isOmpSession, ompAgent, pendingThinkingLevelRef]);
+  }, [isGenerating, isOmpSession, ompAgent, pendingThinkingLevelRef, deferredComposerPickRef]);
 
   const handleModelChange = useCallback((provider: string, modelId: string) => {
     if (!isOmpSession) {
       pendingComposerModelRef.current = { provider, modelId };
       return;
     }
-    void ompAgent.setModel(provider, modelId);
-  }, [isOmpSession, ompAgent, pendingComposerModelRef]);
+    // Same rule as the thinking pick: a mid-run model change is held back so
+    // the answer being streamed finishes on the model it started with, and is
+    // applied right before the next prompt this composer sends.
+    if (isGenerating) {
+      stashComposerPick(deferredComposerPickRef, { provider, modelId });
+      return;
+    }
+    consumeComposerPick(deferredComposerPickRef, { provider, modelId });
+    void applyComposerPick(ompAgent, { provider, modelId });
+  }, [isGenerating, isOmpSession, ompAgent, pendingComposerModelRef, deferredComposerPickRef]);
 
   return {
     handleSend,