@kabmo-labs/kabmo 0.3.1 → 0.4.0

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

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

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The composer's "wait for session" pick, per chat.
+ *
+ * Held in the session's own UI state (`chat.waitingFor`) rather than in
+ * component state: the composer is remounted by a stretch, a tab switch and a
+ * reload, and a pick that evaporated with it would silently send the prompt
+ * immediately — the one outcome the user explicitly deferred.
+ *
+ * The ref is the other half, and it is not redundant: the send handler is
+ * created once per deps record, so reading the pick from render state there
+ * would dispatch with whatever it was when that closure was built.
+ */
+
+import { useCallback, useEffect, useRef } from 'preact/hooks';
+import { useSessionState } from '@/client/hooks/workspace/session-state';
+import type { WaitingCandidate } from '@/client/components/workspace/chat-timeline/chat-input/WaitingDependencyPicker';
+
+export interface WaitingDependencyChoice {
+  value: WaitingCandidate | null;
+  ref: { current: WaitingCandidate | null };
+  set: (candidate: WaitingCandidate | null) => void;
+  clear: () => void;
+}
+
+export function useWaitingDependencyChoice(sessionId: string | null): WaitingDependencyChoice {
+  const [stored, setStored] = useSessionState<WaitingCandidate | null>('chat.waitingFor', null);
+  const ref = useRef<WaitingCandidate | null>(stored);
+  ref.current = stored;
+
+  // The pick belongs to ONE chat's next prompt. A pending chat is replaced by
+  // the id a spawn adopts, which is a different slot — so nothing has to be
+  // cleared for the normal path. This covers the other direction: a session that
+  // is not pending at all has no use for a pick, and a stale value there would
+  // be applied by the next New Session the user opens in that slot.
+  const pending = Boolean(sessionId?.startsWith('new-'));
+  useEffect(() => {
+    if (!pending && stored !== null) setStored(null);
+  }, [pending, stored, setStored]);
+
+  const set = useCallback((candidate: WaitingCandidate | null) => {
+    ref.current = candidate;
+    setStored(candidate);
+  }, [setStored]);
+
+  const clear = useCallback(() => set(null), [set]);
+
+  return { value: stored, ref, set, clear };
+}

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

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Following a held prompt to its outcome.
+ *
+ * The dispatch happens on the SERVER, in a process that may be a different
+ * instance, a different tab's, or one that started after this page was closed.
+ * Nothing on this side sends it, so the only thing that can report it is the
+ * `waiting` topic — and what a dispatched row carries is exactly what the local
+ * send path produces for itself: the omp session id the spawn answered with.
+ *
+ * That is why the adoption is here rather than in the composer: the pending
+ * row's `new-…` id has to move onto the real one whether or not the composer is
+ * still mounted, and whether or not this tab is the one that created it.
+ */
+
+import { useEffect, useRef } from 'preact/hooks';
+import { useWaitingPrompts } from '@/client/hooks/chat/waiting/store';
+import {
+  adoptPendingSession,
+  releasePendingSession,
+} from '@/client/hooks/chat/omp/pending-sessions';
+import { clearPendingSessionWaiting, pendingSessionWait } from '@/client/hooks/chat/omp/pending-waiting';
+import { useSearchParams } from '@/client/lib/router/search-params';
+
+export interface WaitingDispatchOptions {
+  /** Surfaces an outcome the user must know about (a failed or cancelled wait). */
+  onNotice?: (message: string) => void;
+}
+
+/**
+ * Adopt the session a held prompt became, and report the outcomes that are not
+ * a dispatch.
+ *
+ * Mounted once, beside the sidebar's own data provider: every layout needs it,
+ * and the pending row it adopts lives in the same client store both sidebars
+ * read.
+ */
+export function useWaitingDispatch({ onNotice }: WaitingDispatchOptions = {}): void {
+  const { prompts } = useWaitingPrompts();
+  const [, setSearchParams] = useSearchParams();
+  // The toast stack's `pushToast` is a fresh closure per render, so it must not
+  // be an effect dependency: every unrelated render would re-run this walk.
+  const noticeRef = useRef(onNotice);
+  noticeRef.current = onNotice;
+
+  useEffect(() => {
+    for (const prompt of prompts) {
+      const pendingId = prompt.pendingId;
+      if (!pendingId) continue;
+      const held = pendingSessionWait(pendingId);
+
+      if (prompt.status === 'dispatched' && prompt.sessionId) {
+        // Adopt when this tab OWNS the chat: it still holds the cue, or its URL
+        // names the pending id (a reload, a second tab on the same chat). A row
+        // from someone else's chat is left alone — adopting it would mint a
+        // sidebar entry for a session this tab never opened.
+        const openId = new URLSearchParams(window.location.search).get('sessionId');
+        if (!held && openId !== pendingId) continue;
+        adoptPendingSession(pendingId, prompt.sessionId, prompt.folderId);
+        // The URL may still name the pending id — this tab was left on the chat
+        // while the dispatch happened elsewhere.
+        setSearchParams((prev) => {
+          if (prev.get('sessionId') !== pendingId) return prev;
+          const next = new URLSearchParams(prev);
+          next.set('sessionId', prompt.sessionId as string);
+          return next;
+        }, { replace: true });
+        noticeRef.current?.(`Waiting finished — your prompt is now running in a new session.`);
+        continue;
+      }
+
+      if (prompt.status === 'error') {
+        const openId = new URLSearchParams(window.location.search).get('sessionId');
+        if (!held && openId !== pendingId) continue;
+        clearPendingSessionWaiting(pendingId);
+        releasePendingSession(pendingId);
+        noticeRef.current?.(`The prompt you held was not sent: ${prompt.error ?? 'the dispatch failed.'}`);
+        continue;
+      }
+
+      if (prompt.status === 'cancelled' && held) {
+        clearPendingSessionWaiting(pendingId);
+        noticeRef.current?.('The held prompt was cancelled.');
+      }
+    }
+  }, [prompts, setSearchParams]);
+}

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

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The held prompt of the chat on screen, and how to drop it.
+ *
+ * A chat whose prompt is deferred has no session and no transcript, so the
+ * composer is the only place the wait is visible — and it must be DISABLED
+ * while the wait lasts: a second prompt would have nowhere to go.
+ */
+
+import { useCallback, useMemo } from 'preact/hooks';
+import { useWaitingPrompts } from '@/client/hooks/chat/waiting/store';
+import { useCancelWait } from '@/client/hooks/chat/waiting/cancel';
+import type { WaitingPrompt } from '@/shared/types/waiting';
+
+export interface HeldWait {
+  /** The waiting row for the open chat, or null. */
+  heldWait: WaitingPrompt | null;
+  cancelHeldWait: () => void;
+}
+
+export function useHeldWait(
+  sessionId: string | null,
+  isPendingSession: boolean,
+  onNotice?: (message: string, type?: 'success' | 'error') => void,
+): HeldWait {
+  const { prompts } = useWaitingPrompts();
+  const cancelWait = useCancelWait(onNotice);
+  const heldWait = useMemo(
+    () => (isPendingSession
+      ? prompts.find((prompt) => prompt.pendingId === sessionId && prompt.status === 'waiting') ?? null
+      : null),
+    [isPendingSession, sessionId, prompts],
+  );
+  const cancelHeldWait = useCallback(() => {
+    if (heldWait) cancelWait(heldWait.id);
+  }, [heldWait, cancelWait]);
+  return { heldWait, cancelHeldWait };
+}