@kabmo-labs/kabmo 0.3.1 → 0.5.0

package/src/client/hooks/chat/omp/pending-sessions.waiting.test.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The pending store's WAITING rules.
+ *
+ * A held prompt's row is the only thing on screen for a chat that has no
+ * transcript and no omp id, so the store has to keep it for as long as the wait
+ * lasts — and drop the cue the moment the wait ends, or the row keeps claiming
+ * something the server no longer holds.
+ */
+
+import { afterEach, describe, expect, test } from 'bun:test';
+import {
+  adoptPendingSession,
+  listPendingSessions,
+  markPendingSessionSent,
+  reconcilePendingSessions,
+  releasePendingSession,
+  startPendingSession,
+  subscribePendingSessions,
+} from '@/client/hooks/chat/omp/pending-sessions';
+import {
+  clearPendingSessionWaiting,
+  markPendingSessionWaiting,
+  pendingSessionWait,
+  releasePendingSessionByWait,
+} from '@/client/hooks/chat/omp/pending-waiting';
+
+afterEach(() => {
+  for (const entry of listPendingSessions()) releasePendingSession(entry.id);
+});
+
+describe('pending session waiting state', () => {
+  test('a held prompt keeps its row past the settle window', () => {
+    const id = startPendingSession(1);
+    markPendingSessionWaiting(id, { waitId: 'wait-1', dependsOn: 'sess-a', dependsOnTitle: 'Session A' });
+
+    // Far past PENDING_SETTLE_MS, which is the bound a SENT prompt gets.
+    reconcilePendingSessions({
+      listed: new Set(),
+      running: new Set(),
+      activeId: null,
+      now: Date.now() + 10 * 60_000,
+    });
+    expect(listPendingSessions().map((entry) => entry.id)).toContain(id);
+  });
+
+  // The contrast case: a SENT prompt with no wait behind it is released on the
+  // settle window, which is what makes the waiting rule a deliberate exception
+  // rather than a disabled timer.
+  test('an ordinary sent prompt still expires on the settle window', () => {
+    const id = startPendingSession(1);
+    markPendingSessionSent(id);
+    reconcilePendingSessions({ listed: new Set(), running: new Set(), activeId: null, now: Date.now() + 10 * 60_000 });
+    expect(listPendingSessions().map((entry) => entry.id)).not.toContain(id);
+  });
+
+  test('clearing the wait keeps the row but drops the cue', () => {
+    const id = startPendingSession(1);
+    markPendingSessionWaiting(id, { waitId: 'wait-1', dependsOn: 'sess-a', dependsOnTitle: 'Session A' });
+    clearPendingSessionWaiting(id);
+    expect(pendingSessionWait(id)).toBeNull();
+    expect(listPendingSessions().map((entry) => entry.id)).toContain(id);
+  });
+
+  test('a cancelled wait drops its row by the wait id', () => {
+    const first = startPendingSession(1);
+    const second = startPendingSession(1);
+    markPendingSessionWaiting(first, { waitId: 'wait-1', dependsOn: 'sess-a', dependsOnTitle: 'A' });
+    markPendingSessionWaiting(second, { waitId: 'wait-2', dependsOn: 'sess-b', dependsOnTitle: 'B' });
+
+    releasePendingSessionByWait('wait-1');
+    const ids = listPendingSessions().map((entry) => entry.id);
+    expect(ids).not.toContain(first);
+    expect(ids).toContain(second);
+  });
+
+  // The wait ends where the spawn answers: the new row is a real session from
+  // that moment, so a cue carried across would say it is still held.
+  test('adoption drops the waiting cue', () => {
+    const id = startPendingSession(1);
+    markPendingSessionWaiting(id, { waitId: 'wait-1', dependsOn: 'sess-a', dependsOnTitle: 'A' });
+    adoptPendingSession(id, 'omp-session-9', 1);
+    expect(pendingSessionWait('omp-session-9')).toBeNull();
+  });
+
+  // The cue is re-stamped from the server list on every publish, so an identical
+  // write must be a no-op — otherwise every sidebar re-renders on every frame.
+  test('re-stamping the same wait does not notify', () => {
+    const id = startPendingSession(1);
+    const wait = { waitId: 'wait-1', dependsOn: 'sess-a', dependsOnTitle: 'A' };
+    markPendingSessionWaiting(id, wait);
+    let notifications = 0;
+    const stop = subscribePendingSessions(() => { notifications += 1; });
+    markPendingSessionWaiting(id, { ...wait });
+    stop();
+    expect(notifications).toBe(0);
+  });
+});

package/src/client/hooks/chat/omp/pending-waiting.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The WAITING half of the pending store.
+ *
+ * Split from `pending-sessions.ts` for the repo's per-file ceiling, and it is a
+ * clean seam: that file owns an entry's LIFETIME (mint, adopt, retain, drop),
+ * this one owns the single field that says the chat's prompt is deferred. The
+ * store exposes one write hook (`patchPendingEntry`) so the field is still
+ * written through the same map, the same emit and the same no-op check.
+ */
+
+import type { PendingSessionEntry } from '@/client/hooks/chat/omp/pending-sessions';
+import { listPendingSessions, patchPendingEntry } from '@/client/hooks/chat/omp/pending-sessions';
+
+export type PendingWait = NonNullable<PendingSessionEntry['waiting']>;
+
+/**
+ * The chat's prompt is held until another session finishes.
+ *
+ * `sentAt` is set as well, deliberately: the row now stands for a real prompt
+ * the user has committed, so the "an unsent draft with nothing in it may go"
+ * rule must not reclaim it. The waiting half is what survives the switch —
+ * `reconcilePendingSessions` keeps it while the server still reports the row.
+ */
+export function markPendingSessionWaiting(id: string, waiting: PendingWait): void {
+  patchPendingEntry(id, (entry) => ({ ...entry, sentAt: entry.sentAt ?? Date.now(), waiting }));
+}
+
+/** The wait ended (dispatched, cancelled, failed): keep the row, drop the cue. */
+export function clearPendingSessionWaiting(id: string): void {
+  patchPendingEntry(id, (entry) => (entry.waiting ? { ...entry, waiting: undefined } : entry));
+}
+
+/** The waiting half of one entry, or null when the row is not waiting. */
+export function pendingSessionWait(id: string): PendingWait | null {
+  return listPendingSessions().find((entry) => entry.id === id)?.waiting ?? null;
+}
+
+/** Drop the entry whose prompt was held by `waitId` (the wait was cancelled). */
+export function releasePendingSessionByWait(waitId: string): void {
+  for (const entry of listPendingSessions()) {
+    if (entry.waiting?.waitId === waitId) patchPendingEntry(entry.id, () => null);
+  }
+}

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

@@ -30,6 +30,8 @@ import {
   reconcilePendingSessions,
   usePendingSessions,
 } from '@/client/hooks/chat/omp/pending-sessions';
+import { markPendingSessionWaiting } from '@/client/hooks/chat/omp/pending-waiting';
+import { useWaitingPrompts } from '@/client/hooks/chat/waiting/store';
 import { withPendingRows } from '@/client/hooks/chat/omp/pending-rows';
 import { writeSetting } from '@/shared/lib/settings/client';
 import { subscribeSessionKey } from '@/shared/lib/workspace/session-state/listeners';
@@ -150,6 +152,11 @@ export function useSessionSidebarController(
   // A chat omp has not written a transcript for yet. The store owns the row's
   // whole life — see `pending-sessions.ts` — so the sidebar only reads it here.
   const pendingEntries = usePendingSessions();
+  // A held prompt is a property of the SERVER row, not of this tab: a reload (or
+  // a second tab) re-enters a pending chat whose wait it never created, and the
+  // row has to keep saying what it waits for. The cue is therefore re-stamped
+  // from the list on every publish, and cleared when the row is gone.
+  const { prompts: waitingPrompts, loaded: waitingLoaded } = useWaitingPrompts();
   const runningIds = useMemo(
     () => new Set(Object.entries(sessionStatus).filter(([, status]) => status === 'stream').map(([id]) => id)),
     [sessionStatus],
@@ -165,6 +172,28 @@ export function useSessionSidebarController(
     hydratePendingSession(sessionParam, folderIdParam, sessionStatus[sessionParam] === 'stream');
   }, [sessionParam, folders, initializing, folderIdParam, sessionStatus]);
 
+  // The cue is STAMPED from the server list, never cleared from an absence.
+  //
+  // An absence is not evidence: the effect runs on the render a hold triggers,
+  // one frame before the topic's first snapshot, and a snapshot resolved before
+  // the create does not carry the row either. Clearing on that deleted the cue
+  // the user had just made — and, with it, the id the dispatch watcher needs to
+  // adopt. A wait ENDS through a terminal row, which the watcher
+  // (`waiting/dispatch.ts`) reads: dispatched, cancelled or failed.
+  useEffect(() => {
+    if (initializing || !waitingLoaded) return;
+    for (const entry of pendingEntries) {
+      const id = String(entry.id);
+      const held = waitingPrompts.find((prompt) => prompt.pendingId === id && prompt.status === 'waiting');
+      if (!held || entry.waiting?.waitId === held.id) continue;
+      markPendingSessionWaiting(id, {
+        waitId: held.id,
+        dependsOn: held.dependsOn,
+        dependsOnTitle: held.dependsOnTitle,
+      });
+    }
+  }, [pendingEntries, waitingPrompts, waitingLoaded, initializing]);
+
   // A pending chat's row is kept only while its draft still holds something,
   // so the reconcile below has to re-run when a draft SLOT moves — the blob
   // arriving is the common case (a chat opened and left empty has its entry

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

@@ -19,14 +19,15 @@ import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import type { SetSearchParams } from '@/client/lib/router/search-params';
 import { applyComposerPick, consumeComposerPick, stashComposerPick, type DeferredModelStore } from '@/client/hooks/chat/timeline/deferred-model';
 import { useNewChatSubmit } from '@/client/hooks/chat/timeline/new-chat';
-import { dispatchBtwCommand } from '@/client/hooks/chat/btw/intercept';
-import { dispatchPluginCommand } from '@/client/hooks/chat/timeline/plugin-commands';
 import { blockTuiOnlySend } from '@/client/hooks/chat/timeline/tui-only-guard';
+import { dispatchLocalCommand } from '@/client/hooks/chat/timeline/local-commands';
 import { createQueueActions } from '@/client/hooks/chat/timeline/queue-actions';
 import { reportSteerOutcome } from '@/shared/lib/chat/timeline/steer-report';
 import { createRewindActions } from '@/client/hooks/chat/timeline/rewind-actions';
-import { prepareQueuedAttachments } from '@/shared/lib/chat/attachments';
+import { enqueuePreparedFollowUp } from '@/client/hooks/chat/timeline/enqueue-follow-up';
 import { readKabmoSetting } from '@/shared/lib/settings/client';
+import { holdFromComposer } from '@/client/hooks/chat/waiting/hold';
+import type { WaitingCandidate } from '@/client/components/workspace/chat-timeline/chat-input/WaitingDependencyPicker';
 
 export interface ChatTimelineActionsDeps {
   inputValue: string;
@@ -80,6 +81,20 @@ export interface ChatTimelineActionsDeps {
   deferredComposerPickRef: DeferredModelStore;
   /** Global access-control mode, snapshotted onto queued items. */
   accessModeRef: { current: ApprovalMode };
+  /**
+   * The composer's "wait for session" pick, mirrored in a ref: the send handler
+   * is created once per deps record, and reading the pick from render state
+   * would send with whatever it was when that closure was built.
+   */
+  waitingDependencyRef?: { current: WaitingCandidate | null };
+  /** Clear the pick once the prompt is held (the wait now owns it). */
+  clearWaitingDependency?: () => void;
+  /** Server-tracked `stream` rows: re-checked at send, so a dependency that
+   *  finished while the draft was being written sends normally. */
+  streamStatusMap?: Record<string, 'stream' | 'finish' | 'abort'>;
+  /** Plan/goal flags the held spawn must carry (read when the wait is created,
+   *  because the dispatch happens in another process later). */
+  spawnSelectionRef?: { current: { plan: boolean; goal: boolean } | null };
   setSearchParams: SetSearchParams;
   /**
    * Surface a footer action that failed (rewind refused, send rejected). Undo
@@ -137,17 +152,14 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
   // they are built once per render from it rather than re-listing every field.
   const queueActions = useMemo(() => createQueueActions(deps), [deps]);
 
-  /** Snapshot the composer's model/thinking plus the live access mode onto a
-   *  queued item, so server-side auto-delivery replays exactly these settings.
-   *  The queue row is JSON — a `File` does not survive it — so text contents
-   *  and display fields are captured while the live handle still exists. */
-  const enqueueFollowUp = useCallback((text: string, attachments: Attachment[]) => {
-    const composerPick = composerModelRef.current;
-    const model = composerPick ? { ...composerPick, accessMode: accessModeRef.current } : null;
-    void prepareQueuedAttachments(attachments).then((prepared) => {
-      enqueueMessage({ text, attachments: prepared, model });
-    });
-  }, [composerModelRef, accessModeRef, enqueueMessage]);
+  const enqueueFollowUp = useCallback(
+    (text: string, attachments: Attachment[]) => enqueuePreparedFollowUp(
+      { composerModelRef, accessModeRef, enqueueMessage },
+      text,
+      attachments,
+    ),
+    [composerModelRef, accessModeRef, enqueueMessage],
+  );
 
   const handleSend = useCallback(async (attachments: Attachment[], options?: { steering?: boolean }) => {
     const textToSend = inputValue.trim();
@@ -157,26 +169,8 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     // resume delivering after this run ends.
     stopHoldRef.current = false;
 
-    // `/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 Kabmo answers with a panel.
-    if (dispatchBtwCommand(textToSend, attachments)) {
-      setInputValue('');
-      return;
-    }
-
-    // A command a PLUGIN contributed through the `commandPaletteAction` slot is
-    // answered by that plugin, exactly like a Kabmo command: it is local work
-    // the popup advertised, so it must never reach the model as literal text
-    // (RPC has no expansion for it, and omp would improvise a whole turn around
-    // the string). MUST run before the TUI-only guard below: a plugin may
-    // legitimately claim a name omp implements only in its TUI, and refusing
-    // the row the popup just offered would be the composer contradicting itself.
-    if (dispatchPluginCommand(textToSend)) {
+    // Commands Kabmo answers ITSELF, before anything can reach the model.
+    if (dispatchLocalCommand(textToSend, attachments)) {
       setInputValue('');
       return;
     }
@@ -187,6 +181,11 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     // keep the draft so the user can edit or retype it.
     if (blockTuiOnlySend(textToSend, setLocalMessages)) return;
 
+    // A NEW chat whose prompt is held for another session: nothing is sent now,
+    // and the pending row stays on screen saying what it waits for. Checked
+    // before the queue-vs-send split — a pending chat has no run to queue behind.
+    if (await holdFromComposer(deps, textToSend, attachments, isGenerating || chatRunning)) return;
+
     // "A run is in flight" is the CHAT-level flag, not this client's own:
     // `isGenerating` only knows the run THIS page started, so a second tab, a
     // scheduled task, the goal driver's continuation or a page that never
@@ -234,7 +233,7 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     // branch would rather than losing the message. Every other failure may
     // already have been accepted, and is reported by the send path instead.
     if (result.busy) enqueueFollowUp(textToSend, attachments);
-  }, [inputValue, isGenerating, chatRunning, executeSend, enqueueMessage, enqueueFollowUp, isOmpSession, appSettings, steerOmpAgent, setInputValue, abortControllerRef, setGenerating, stopHoldRef, composerModelRef, accessModeRef, setLocalMessages]);
+  }, [deps, inputValue, isGenerating, chatRunning, executeSend, enqueueMessage, enqueueFollowUp, isOmpSession, appSettings, steerOmpAgent, setInputValue, abortControllerRef, setGenerating, stopHoldRef, composerModelRef, accessModeRef, setLocalMessages]);
 
   const handleEditQueueItem = useCallback((item: QueuedMessage) => {
     queueActions.handleEditQueueItem(item);

package/src/client/hooks/chat/timeline/composer-refs.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The composer's model/thinking refs, and the one rule that ties them to a
+ * session.
+ *
+ * Three of the four are mirrors of picks the user made, and they exist because
+ * the send path cannot read render state: it is created once per deps record,
+ * so a pick read from a prop there would dispatch with whatever it was when
+ * that closure was built. The fourth (`deferredComposerPickRef`) holds a pick
+ * made WHILE a turn streams, so it cannot re-target the answer in flight.
+ *
+ * Split out of `timeline/index.ts` for the per-file ceiling; the semantics are
+ * the hook's own and are documented at each field.
+ */
+
+import { useEffect, useRef } from 'preact/hooks';
+import type { ComposerModelPick } from '@/client/hooks/chat/timeline/deferred-model';
+
+export interface ComposerRefs {
+  /** Model picked on a pending `new-…` chat; applied to the spawn. */
+  pendingComposerModelRef: { current: { provider: string; modelId: string } | null };
+  /** Same, for the thinking level. */
+  pendingThinkingLevelRef: { current: string | null };
+  /** Live mirror of the composer's pick; snapshotted onto queued items. */
+  composerModelRef: { current: { provider: string; modelId: string; thinkingLevel: string } | null };
+  /** A pick made mid-run, pushed right before the next prompt this composer starts. */
+  deferredComposerPickRef: { current: ComposerModelPick | null };
+}
+
+export function useComposerRefs(sessionId: string | null): ComposerRefs {
+  const pendingComposerModelRef = useRef<{ provider: string; modelId: string } | null>(null);
+  const pendingThinkingLevelRef = useRef<string | null>(null);
+  const composerModelRef = useRef<{ provider: string; modelId: string; thinkingLevel: string } | null>(null);
+  const deferredComposerPickRef = useRef<ComposerModelPick | null>(null);
+
+  // A stashed pick belongs to ONE session's next prompt: carrying it across a
+  // switch would silently re-target the session the user just opened.
+  useEffect(() => {
+    deferredComposerPickRef.current = null;
+  }, [sessionId]);
+
+  return { pendingComposerModelRef, pendingThinkingLevelRef, composerModelRef, deferredComposerPickRef };
+}

package/src/client/hooks/chat/timeline/enqueue-follow-up.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Snapshot a follow-up onto the server-backed queue.
+ *
+ * The composer's model/thinking pick plus the live access mode ride along, so
+ * auto-delivery replays exactly these settings instead of whatever the session
+ * happens to run with at delivery time. The queue row is JSON — a live `File`
+ * does not survive it — so text contents and display fields are captured HERE,
+ * while the handle still exists.
+ */
+
+import type { Attachment, QueuedMessage, QueuedMessageModel } from '@/shared/types/chat';
+import { prepareQueuedAttachments } from '@/shared/lib/chat/attachments';
+
+export interface FollowUpSnapshotDeps {
+  composerModelRef: { current: { provider: string; modelId: string; thinkingLevel: string } | null };
+  accessModeRef: { current: string };
+  enqueueMessage: (item: Omit<QueuedMessage, 'id'>) => void;
+}
+
+export function enqueuePreparedFollowUp(
+  deps: FollowUpSnapshotDeps,
+  text: string,
+  attachments: Attachment[],
+): void {
+  const composerPick = deps.composerModelRef.current;
+  const model: QueuedMessageModel | null = composerPick
+    ? { ...composerPick, accessMode: deps.accessModeRef.current as QueuedMessageModel['accessMode'] }
+    : null;
+  void prepareQueuedAttachments(attachments).then((prepared) => {
+    deps.enqueueMessage({ text, attachments: prepared, model });
+  });
+}

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

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
+import { useCallback, useRef, useState } from 'preact/hooks';
 import { useTimelineScope } from '@/client/hooks/chat/timeline/scope';
 import type { ChatMessageData } from '@/shared/types';
 import { useOmpAgent } from '@/client/hooks/chat/omp';
@@ -9,7 +9,6 @@ import { useGeneratingState } from '@/client/hooks/chat/timeline/generating';
 import { useTimelineAutoScroll } from '@/client/hooks/chat/timeline/auto-scroll';
 import { useChatTimelineActions } from '@/client/hooks/chat/timeline/actions';
 import { useChatTimelineSend } from '@/client/hooks/chat/timeline/send';
-import type { ComposerModelPick } from '@/client/hooks/chat/timeline/deferred-model';
 import { useSessionLoad } from '@/client/hooks/chat/timeline/session-load';
 import { useUserTurns } from '@/client/hooks/chat/timeline/user-turns';
 import { useRailJump } from '@/client/hooks/chat/timeline/rail-jump';
@@ -19,6 +18,8 @@ import { useChatTimelineAccessMode } from '@/client/hooks/chat/timeline/access-m
 import { useComposerModes } from '@/client/hooks/chat/timeline/composer-modes';
 import { useComposerDraft } from '@/client/hooks/chat/composer/use-draft';
 import { isChatRunning } from '@/client/hooks/chat/omp/session-statuses';
+import { useWaitingDependencyChoice } from '@/client/hooks/chat/waiting/choice';
+import { useComposerRefs } from '@/client/hooks/chat/timeline/composer-refs';
 
 interface UseChatTimelineOptions {
   folders?: any[];
@@ -157,28 +158,18 @@ export function useChatTimeline({
   });
   const jumpToUserTurn = useRailJump(pagedJumpToTurn, { followRef, scrollRef });
 
-  // Composer picks made BEFORE the omp session exists (pending "new-…" view):
-  // there is no live session to receive the RPC yet, so the selection is held
-  // here and applied to the spawn command on first send.
-  const pendingComposerModelRef = useRef<{ provider: string; modelId: string } | null>(null);
-  const pendingThinkingLevelRef = useRef<string | null>(null);
-  // Live mirror of the composer's model/thinking pick: the enqueue path
-  // snapshots it onto queued items so auto-delivery replays those settings.
-  const composerModelRef = useRef<{ provider: string; modelId: string; thinkingLevel: string } | null>(null);
-  // Picks made WHILE a turn streams: held here so they cannot re-target the
-  // answer in flight (omp applies set_model to the running turn), and pushed
-  // onto the session right before the next prompt.
-  const deferredComposerPickRef = useRef<ComposerModelPick | null>(null);
-  // A stashed pick belongs to ONE session's next prompt: carrying it across a
-  // switch would silently re-target the session the user just opened.
-  useEffect(() => {
-    deferredComposerPickRef.current = null;
-  }, [sessionId]);
+  // The composer's model/thinking mirrors and the mid-run stash (see the hook).
+  const { pendingComposerModelRef, pendingThinkingLevelRef, composerModelRef, deferredComposerPickRef } =
+    useComposerRefs(sessionId);
 
   // Access control is a GLOBAL, persisted user preference (unlike the
   // per-session model/thinking picks).
   const { accessMode, accessModeRef, setAccessMode: handleAccessModeChange } = useChatTimelineAccessMode(appSettings);
 
+  // "Wait for session" on a NEW chat: the pick, and the ref the send handler
+  // reads (see `choice.ts` for why both).
+  const waitingDependency = useWaitingDependencyChoice(sessionId);
+
   const persistMessages = useCallback((messagesToSave: any[]) => {
     if (!sessionId) return;
     fetch(`/api/chat/${sessionId}`, {
@@ -291,6 +282,10 @@ export function useChatTimeline({
     composerModelRef,
     deferredComposerPickRef,
     accessModeRef,
+    waitingDependencyRef: waitingDependency.ref,
+    clearWaitingDependency: waitingDependency.clear,
+    streamStatusMap,
+    spawnSelectionRef: modes.spawnSelectionRef,
     setSearchParams,
     reportActionError,
   });
@@ -343,6 +338,7 @@ export function useChatTimeline({
     planReview,
     composerModelRef,
     deferredComposerPickRef,
+    waitingDependency,
     extensionDialogs,
     resolveExtensionDialog,
     respondToExtensionUi: ompAgent.respondToExtensionUi,

package/src/client/hooks/chat/timeline/local-commands.ts

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Commands Kabmo answers itself, checked before anything can reach the model.
+ *
+ * Two of them, and both MUST run ahead of the TUI-only guard:
+ *
+ *   - `/btw [question]` is the side-question panel's entry point. omp implements
+ *     `/btw` in its TUI only, so the guard would refuse the very command Kabmo
+ *     answers — a bare `/btw` just opens the panel's history.
+ *   - a command a PLUGIN contributed through `commandPaletteAction` is local
+ *     work the popup advertised, so it must never arrive as literal text (RPC
+ *     has no expansion for it, and omp would improvise a turn around the
+ *     string). A plugin may legitimately claim a name omp implements only in its
+ *     TUI, and refusing the row the popup just offered would be the composer
+ *     contradicting itself.
+ */
+
+import type { Attachment } from '@/shared/types/chat';
+import { dispatchBtwCommand } from '@/client/hooks/chat/btw/intercept';
+import { dispatchPluginCommand } from '@/client/hooks/chat/timeline/plugin-commands';
+
+/** True when the text was answered locally — the caller clears the composer and returns. */
+export function dispatchLocalCommand(text: string, attachments: Attachment[]): boolean {
+  return dispatchBtwCommand(text, attachments) || dispatchPluginCommand(text);
+}

package/src/client/hooks/chat/timeline/queue-rewind.test.ts

@@ -28,6 +28,7 @@ import type { QueuedMessage } from '@/shared/types';
 import { SessionStateContext } from '@/client/hooks/workspace/session-state/context';
 import { useChatTimelineQueue, type ChatTimelineQueueResult } from '@/client/hooks/chat/timeline/queue';
 import { requestRewind } from '@/client/hooks/chat/timeline/rewind';
+import { restoreRealtime, silenceRealtime } from '@/test-support/silent-socket';
 
 const DOM_GLOBALS = ['window', 'document', 'navigator', 'Node', 'Element', 'HTMLElement', 'Event', 'CustomEvent'] as const;
 /** The runner's own globals, restored on teardown so later files still have them. */
@@ -80,12 +81,17 @@ afterAll(() => {
   }
 });
 beforeEach(() => {
+  // The queue hook subscribes to its session topic on mount, and this origin has
+  // no listener: a real dial would fail asynchronously, after the globals are
+  // restored. Per case, because `restoreRealtime` clears the constructor.
+  silenceRealtime();
   calls.length = 0;
   canonical = [];
   gate = null;
   stubFetch();
 });
 afterEach(() => {
+  restoreRealtime();
   if (container) render(null, container);
   container?.remove();
   latest = null;

package/src/client/hooks/chat/timeline/run-identity.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The provider/model the generating indicator names a run by.
+ *
+ * The run's model is persisted BESIDE the stream status and rides the sidebar
+ * payload, so the indicator names the real provider/model even for a run this
+ * page never started. The transcript is the fallback, not the source: a freshly
+ * spawned session has no readable JSONL yet, and one loaded from history may
+ * carry a model the run has since switched away from.
+ */
+
+import { useMemo } from 'preact/hooks';
+import type { WorkspaceFolderData } from '@/shared/types';
+import type { SessionDataShape } from '@/client/hooks/chat/timeline/session-load';
+
+export interface RunIdentity {
+  sessionProvider?: string;
+  sessionModelName?: string;
+}
+
+export function useRunIdentity(input: {
+  folders: WorkspaceFolderData[];
+  sessionId: string | null;
+  sessionData: SessionDataShape | null | undefined;
+  modelNames: Record<string, string>;
+}): RunIdentity {
+  const { folders, sessionId, sessionData, modelNames } = input;
+  const runModel = useMemo(
+    () => folders.flatMap((f) => f.sessions ?? []).find((s) => String(s.id) === String(sessionId))?.runModel ?? null,
+    [folders, sessionId],
+  );
+  const fallback = sessionData?.model;
+  const fallbackModel = typeof fallback === 'object' ? fallback : null;
+  const sessionModelId = runModel?.modelId ?? fallbackModel?.modelId;
+  return {
+    sessionProvider: runModel?.provider ?? fallbackModel?.provider,
+    sessionModelName: sessionModelId
+      ? (modelNames[sessionModelId] ?? sessionModelId)
+      : (typeof fallback === 'string' ? fallback : undefined),
+  };
+}

package/src/client/hooks/chat/waiting/cancel.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Dropping a held prompt from the row that shows it.
+ *
+ * A refusal is REPORTED: the only two refusals are "already sent" (the prompt
+ * is running now, so Stop the session instead) and "no longer there", and both
+ * leave the row on screen. Swallowing them would leave a row that looks stuck
+ * with no way to learn why.
+ */
+
+import { useCallback } from 'preact/hooks';
+import { cancelWaitingPromptRequest } from '@/client/hooks/chat/waiting/store';
+import { releasePendingSessionByWait } from '@/client/hooks/chat/omp/pending-waiting';
+
+export type CancelWait = (waitId: string) => void;
+
+export function useCancelWait(onNotice?: (message: string, type?: 'success' | 'error') => void): CancelWait {
+  return useCallback((waitId: string) => {
+    void cancelWaitingPromptRequest(waitId).then((result) => {
+      if (!result.ok) {
+        onNotice?.(result.error ?? 'Could not cancel the waiting prompt.', 'error');
+        return;
+      }
+      // The row existed only for this wait, so it goes with it. The topic
+      // republish also removes the cue; doing it here keeps the click instant.
+      releasePendingSessionByWait(waitId);
+      onNotice?.('Waiting prompt cancelled.', 'success');
+    });
+  }, [onNotice]);
+}