ompchamber 0.6.0 → 0.8.0

package/src/client/hooks/chat/omp/prompt-send.ts

@@ -0,0 +1,161 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Prompt delivery for the live omp bridge: warm the session up, attach the
+ * event stream, POST the prompt, then signal the sidebars the moment it is
+ * dispatched.
+ *
+ * The signal is the point: the server writes the live `stream` row when it
+ * dispatches the prompt, so waiting for `agent_start` (spawn + ack round trip)
+ * would leave the sidebar spinner dark for seconds after the user hit send.
+ * Extracted from useOmpAgent so that hook stays under the repo's per-file size
+ * ceiling.
+ */
+
+import { useCallback } from 'preact/hooks';
+import type { Dispatch, SetStateAction } from 'preact/compat';
+import type { OmpAgentState } from '@/shared/types';
+import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
+
+export interface OmpPromptSenderDeps {
+  /** Live session id the prompt targets; the caller mirrors its prop into it. */
+  sessionIdRef: { current: string | null };
+  /** Attach the event stream to a spawned session. */
+  connect: (sessionId: string) => void;
+  setState: Dispatch<SetStateAction<OmpAgentState>>;
+}
+
+export interface OmpPromptSender {
+  sendPrompt: (message: string, images?: { data: string; mimeType: string }[], options?: { accessMode?: ApprovalMode }) => Promise<boolean>;
+  sendNewPrompt: (
+    message: string,
+    cwd: string,
+    images?: { data: string; mimeType: string }[],
+    composerOptions?: { model?: { provider: string; modelId: string } | null; thinkingLevel?: string | null; accessMode?: ApprovalMode },
+  ) => Promise<{ sessionId: string; model: { provider: string; modelId: string } | null } | null>;
+}
+
+export function useOmpPromptSender(deps: OmpPromptSenderDeps): OmpPromptSender {
+  const { sessionIdRef, connect, setState } = deps;
+
+  /** Send a prompt to the omp session via the RPC bridge. */
+  const sendPrompt = useCallback(async (
+    message: string,
+    images?: { data: string; mimeType: string }[],
+    options?: { accessMode?: ApprovalMode },
+  ) => {
+    const sid = sessionIdRef.current;
+    if (!sid) return false;
+    setState((prev) => ({ ...prev, isGenerating: true, error: null }));
+    try {
+      // Mirror omp-web handleSend: warm the session process up with get_state
+      // (spawns it on first use), then attach the event stream before sending
+      // the prompt so no agent events are missed.
+      const warmup = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        // The mode rides the warmup too: this is the request that lazily spawns
+        // an idle session, and omp only accepts --approval-mode at spawn time.
+        body: JSON.stringify({
+          type: 'get_state',
+          ...(options?.accessMode ? { accessMode: options.accessMode } : {}),
+        }),
+      });
+      if (warmup.ok) connect(sid);
+
+      const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'prompt',
+          message,
+          ...(images?.length ? { images } : {}),
+          ...(options?.accessMode ? { accessMode: options.accessMode } : {}),
+        }),
+      });
+      const body = (await res.json().catch(() => ({}))) as { success?: boolean; error?: string };
+      if (!res.ok || body.error) {
+        // `session_busy`: the ack timed out behind a still-running turn, so the
+        // prompt may already be accepted — never resend it automatically.
+        setState((prev) => ({ ...prev, isGenerating: false, error: body.error ?? `HTTP ${res.status}` }));
+        return false;
+      }
+      // Tell the sidebars to re-read the session list now — the server wrote
+      // this session's live `stream` row at dispatch. Revalidation is
+      // leading-edge throttled, so this lands immediately.
+      window.dispatchEvent(new CustomEvent('omp:session-updated', { detail: { sessionId: sid } }));
+      return true;
+    } catch (e) {
+      setState((prev) => ({ ...prev, isGenerating: false, error: e instanceof Error ? e.message : String(e) }));
+      return false;
+    }
+  }, [connect, sessionIdRef, setState]);
+
+  /** Spawn a brand-new omp session and send the first prompt: ensure_session
+   *  first (returns omp's real session id), attach the event stream, then send
+   *  the prompt through the existing session route so no agent events are
+   *  missed. Model/thinking picks ride the ensure_session body so omp applies
+   *  them BEFORE the first prompt (and their JSONL change entries are written
+   *  up front, not after the run starts). Returns the new session id on
+   *  success, or null on failure — the caller adopts the id as the active
+   *  session. */
+  const sendNewPrompt = useCallback(async (
+    message: string,
+    cwd: string,
+    images?: { data: string; mimeType: string }[],
+    composerOptions?: { model?: { provider: string; modelId: string } | null; thinkingLevel?: string | null; accessMode?: ApprovalMode },
+  ): Promise<{ sessionId: string; model: { provider: string; modelId: string } | null } | null> => {
+    setState((prev) => ({ ...prev, isGenerating: true, error: null }));
+    try {
+      const created = await fetch('/api/agent/new', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'ensure_session',
+          cwd,
+          ...(composerOptions?.model ? composerOptions.model : {}),
+          ...(composerOptions?.thinkingLevel ? { thinkingLevel: composerOptions.thinkingLevel } : {}),
+          ...(composerOptions?.accessMode ? { accessMode: composerOptions.accessMode } : {}),
+        }),
+      });
+      const createdBody = (await created.json().catch(() => ({}))) as {
+        success?: boolean;
+        sessionId?: string;
+        model?: { provider: string; modelId: string } | null;
+        error?: string;
+      };
+      if (!created.ok || !createdBody.sessionId) {
+        setState((prev) => ({ ...prev, isGenerating: false, error: createdBody.error ?? `HTTP ${created.status}` }));
+        return null;
+      }
+      const sid = createdBody.sessionId;
+      connect(sid);
+      const res = await fetch(`/api/agent/${encodeURIComponent(sid)}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          type: 'prompt',
+          message,
+          ...(images?.length ? { images } : {}),
+        }),
+      });
+      const body = (await res.json().catch(() => ({}))) as { success?: boolean; error?: string };
+      if (!res.ok || body.error) {
+        setState((prev) => ({ ...prev, isGenerating: false, error: body.error ?? `HTTP ${res.status}` }));
+        return null;
+      }
+      // Same dispatch-time signal as sendPrompt: the new session's live badge
+      // must not wait for agent_start + the first JSONL write.
+      window.dispatchEvent(new CustomEvent('omp:session-updated', { detail: { sessionId: sid } }));
+      return { sessionId: sid, model: createdBody.model ?? null };
+    } catch (e) {
+      setState((prev) => ({ ...prev, isGenerating: false, error: e instanceof Error ? e.message : String(e) }));
+      return null;
+    }
+  }, [connect, setState]);
+
+  return { sendPrompt, sendNewPrompt };
+}

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

@@ -21,6 +21,7 @@ import type { ReactNode } from 'preact/compat';
 import { useFetcher } from '@/client/lib/router/fetcher';
 import { usePanelRefresh } from '@/client/hooks/workspace/panel-refresh';
 import { SIDEBAR_IDLE_REFRESH_MS } from '@/shared/lib/workspace/refresh-cadence';
+import { useInputRequiredAlert } from '@/client/hooks/ui/input-required-alert';
 import type { WorkspaceFolderData } from '@/shared/types';
 import type { SessionListPayload } from '@/server/lib/omp/session/sidebar-data.server';
 
@@ -87,6 +88,9 @@ export function SidebarDataProvider({ children, initialFolders = [] }: { childre
       folder.sessions?.some((session) => session.streamStatus === 'stream'),
     ),
   );
+  // Fires for ANY session, including one this tab never opened — the cue that an
+  // agent is blocked on an answer must not depend on the open timeline.
+  useInputRequiredAlert(fetcher.data?.folders ?? []);
   usePanelRefresh(refresh, !hasStreaming, SIDEBAR_IDLE_REFRESH_MS);
 
   const markSeen = useCallback((sessionId: number | string) => {

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

@@ -49,8 +49,6 @@ export interface ChatTimelineActionsDeps {
   /** Global access-control mode, snapshotted onto queued items. */
   accessModeRef: { current: ApprovalMode };
   setSearchParams: (fn: (prev: URLSearchParams) => URLSearchParams, opts?: { replace?: boolean }) => void;
-  /** Advance the pending-dialog queue after the head was answered. */
-  dismissExtensionDialog: () => void;
 }
 
 export interface ChatTimelineActionsResult {
@@ -64,7 +62,6 @@ export interface ChatTimelineActionsResult {
   stopGenerating: () => number;
   handleThinkingLevelChange: (level: string) => void;
   handleModelChange: (provider: string, modelId: string) => void;
-  closeExtensionDialog: () => void;
 }
 
 export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimelineActionsResult {
@@ -91,7 +88,6 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     composerModelRef,
     accessModeRef,
     setSearchParams,
-    dismissExtensionDialog,
   } = deps;
 
   const handleSend = useCallback(async (attachments: Attachment[], options?: { steering?: boolean }) => {
@@ -302,10 +298,6 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     void ompAgent.setModel(provider, modelId);
   }, [isOmpSession, ompAgent, pendingComposerModelRef]);
 
-  const closeExtensionDialog = useCallback(() => {
-    dismissExtensionDialog();
-  }, [dismissExtensionDialog]);
-
   return {
     handleSend,
     handleEditQueueItem,
@@ -316,6 +308,5 @@ export function useChatTimelineActions(deps: ChatTimelineActionsDeps): ChatTimel
     stopGenerating,
     handleThinkingLevelChange,
     handleModelChange,
-    closeExtensionDialog,
   };
 }

package/src/client/hooks/chat/timeline/ask-frames.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Routes omp's pending answerable dialogs to their renderer.
+ *
+ * `ask` dialogs belong on the tool card that raised them — a modal would hide
+ * every question but the one in flight, and the tool's own result (all questions
+ * and their answers) is what the user reads afterwards. Everything else
+ * (approval gates under `always-ask`, extension pickers) has no card of its own
+ * and keeps the modal.
+ *
+ * The two are told apart by the running ask tool calls: a frame whose title
+ * names one of their questions is theirs, and a frame that follows such a frame
+ * (the `editor` omp opens after "Other (type your own)") belongs with it too.
+ * Any frame left over is modal material — including an ask-shaped frame whose
+ * tool call the timeline has not seen, which must stay answerable rather than
+ * silently vanish.
+ */
+
+import { createContext, useContext } from 'preact/compat';
+import type { ChatMessageData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+import { groupAskFrames, isAskToolCall, normalizeAskText, parseAskQuestions, type AskQuestion } from '@/shared/lib/chat/ask-questions';
+import type { ExtensionDialogResponse } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/Lazy';
+
+export interface AskFramesSplit {
+  /** The ask's dialogs, bucketed per question, keyed by ask tool-call id. */
+  framesByTool: Map<string, ExtensionUiDialogRequest[][]>;
+  /** Oldest request no ask card owns — the one the modal renders, if any. */
+  modalRequest: ExtensionUiDialogRequest | null;
+}
+
+export interface AskFramesHandle {
+  framesByTool: AskFramesSplit['framesByTool'];
+  /** Answer one ask dialog and drop it from the pending queue. */
+  respond: (request: ExtensionUiDialogRequest, response: ExtensionDialogResponse) => void;
+}
+
+const EMPTY: AskFramesHandle = { framesByTool: new Map(), respond: () => {} };
+
+export const AskFramesContext = createContext<AskFramesHandle>(EMPTY);
+
+/** Pending ask dialogs for the timeline that provides them. */
+export function useAskFrames(): AskFramesHandle {
+  return useContext(AskFramesContext);
+}
+
+export function splitAskFrames(
+  messages: ChatMessageData[],
+  pending: ExtensionUiDialogRequest[],
+): AskFramesSplit {
+  const framesByTool = new Map<string, ExtensionUiDialogRequest[][]>();
+  if (pending.length === 0) return { framesByTool, modalRequest: null };
+
+  // Match against EVERY ask the timeline knows, not just the running ones: a
+  // reloaded session reads its tool calls back from the JSONL, where a call
+  // still parked on a question has no result yet and so cannot be told from a
+  // finished one. The pending queue is the part that is authoritative — it only
+  // ever holds frames omp is still blocked on — so a title match is enough.
+  const openAsks = new Map<string, AskQuestion[]>();
+  for (const message of messages) {
+    for (const tool of message.toolCalls ?? []) {
+      if (!isAskToolCall(tool)) continue;
+      const questions = parseAskQuestions(tool);
+      if (questions.length > 0) openAsks.set(tool.id, questions);
+    }
+  }
+
+  const owned = new Map<string, ExtensionUiDialogRequest[]>();
+  const claimed = new Set<ExtensionUiDialogRequest>();
+  let lastOwner: string | null = null;
+
+  for (const request of pending) {
+    const title = typeof request.title === 'string' ? normalizeAskText(request.title) : '';
+    let owner: string | null = null;
+    if (title) {
+      for (const [toolId, questions] of openAsks) {
+        if (questions.some((question) => normalizeAskText(question.question) === title)) {
+          owner = toolId;
+          break;
+        }
+      }
+    }
+    // The dialog omp opens after "Other (type your own)" names the question in
+    // its title only loosely; it continues whichever ask spoke last. An
+    // approval gate is never part of an ask, so it keeps its own modal.
+    if (!owner && request.method !== 'confirm') owner = lastOwner;
+    if (!owner) continue;
+    claimed.add(request);
+    lastOwner = owner;
+    owned.set(owner, [...(owned.get(owner) ?? []), request]);
+  }
+
+  for (const [toolId, frames] of owned) {
+    framesByTool.set(toolId, groupAskFrames(openAsks.get(toolId) ?? [], frames));
+  }
+
+  return { framesByTool, modalRequest: pending.find((request) => !claimed.has(request)) ?? null };
+}

package/src/client/hooks/chat/timeline/extension-dialog.ts

@@ -13,19 +13,22 @@
  * tool call stayed blocked on an approval nobody could answer and the turn never
  * reached `agent_end` — the run looked hung until Stop.
  *
- * Requests surface one at a time in arrival order; answering the head advances
- * the queue. Extracted from useChatTimeline to stay under the size ceiling.
+ * The queue keeps EVERY pending request rather than the head alone: `ask` raises
+ * one frame per question, and those are rendered inline on the ask tool card
+ * (see ask-frames.ts) instead of in a modal, so the head is not the only
+ * answerable request at any moment. Entries leave the queue by id once their
+ * response is on the wire, or when omp withdraws them (`method: 'cancel'`).
  */
 
 import { useCallback, useEffect, useState } from 'preact/hooks';
 import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
 
 export interface ExtensionDialogQueue {
-  /** Head of the queue — the single dialog to render. */
-  dialog: ExtensionUiDialogRequest | null;
+  /** Still-blocking requests, in omp's arrival order. */
+  pending: ExtensionUiDialogRequest[];
   enqueue: (request: ExtensionUiDialogRequest) => void;
-  /** Advance past the head once its response has been sent. */
-  dismiss: () => void;
+  /** Advance past a request once its response has been sent. */
+  resolve: (id: string) => void;
   /** Drop a request omp withdrew (`method: 'cancel'`) without an answer. */
   withdraw: (targetId: string) => void;
 }
@@ -45,12 +48,12 @@ export function useExtensionDialogQueue(sessionId: string | null): ExtensionDial
     // entry per omp id keeps the queue answerable exactly once.
     setQueue((current) => (current.some((pending) => pending.id === request.id) ? current : [...current, request]));
   }, []);
-  const dismiss = useCallback(() => {
-    setQueue((current) => current.slice(1));
+  const resolve = useCallback((id: string) => {
+    setQueue((current) => current.some((pending) => pending.id === id) ? current.filter((pending) => pending.id !== id) : current);
   }, []);
   const withdraw = useCallback((targetId: string) => {
     setQueue((current) => current.filter((pending) => pending.id !== targetId));
   }, []);
 
-  return { dialog: queue[0] ?? null, enqueue, dismiss, withdraw };
+  return { pending: queue, enqueue, resolve, withdraw };
 }

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

@@ -120,7 +120,7 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     sessionData,
     adoptedSessionIdRef,
     refreshSessionMeta,
-    setSessionModel,
+    seedSession,
     hasMore,
     loadingOlder,
     loadOlderError,
@@ -183,9 +183,9 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     removeDeliveredFromQueue,
   } = useChatTimelineQueue(sessionId);
   const {
-    dialog: extensionDialog,
+    pending: extensionDialogs,
     enqueue: enqueueExtensionDialog,
-    dismiss: dismissExtensionDialog,
+    resolve: resolveExtensionDialog,
     withdraw: withdrawExtensionDialog,
   } = useExtensionDialogQueue(sessionId);
 
@@ -226,7 +226,7 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     adoptedSessionIdRef,
     optimisticUserIdRef,
     pendingUserDisplaysRef,
-    setSessionModel,
+    seedSession,
     pendingComposerModelRef,
     pendingThinkingLevelRef,
     composerModelRef,
@@ -262,7 +262,6 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     stopGenerating,
     handleThinkingLevelChange,
     handleModelChange,
-    closeExtensionDialog,
   } = useChatTimelineActions({
     inputValue,
     setInputValue,
@@ -286,7 +285,6 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     composerModelRef,
     accessModeRef,
     setSearchParams,
-    dismissExtensionDialog,
   });
 
   return {
@@ -331,8 +329,8 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     accessMode,
     handleAccessModeChange,
     composerModelRef,
-    extensionDialog,
-    closeExtensionDialog,
+    extensionDialogs,
+    resolveExtensionDialog,
     respondToExtensionUi: ompAgent.respondToExtensionUi,
   };
 }

package/src/client/hooks/chat/timeline/prompt-text.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Prompt assembly for the chamber composer: rewrite composer-level mentions
+ * into what oh-my-pi actually receives, then inline the text attachments the
+ * user dropped in. Extracted from the send path so that hook stays under the
+ * repo's per-file size ceiling.
+ */
+
+import { composeMessageWithTextAttachments } from '@/shared/lib/chat/attachments';
+import { loadAgentNames } from '@/shared/lib/chat/composer/client';
+import { translateAgentMentions, translateFileMentions } from '@/shared/lib/chat/composer/translate';
+
+type TextFileAttachment = Parameters<typeof composeMessageWithTextAttachments>[1][number];
+
+/**
+ * Build the outgoing prompt. `@agent` mentions are rewritten into an explicit
+ * task-tool delegation directive at send time (oh-my-pi has no `@agent`
+ * syntax); translation failures fall back to the raw prompt.
+ */
+export async function buildPromptText(text: string, textFiles: TextFileAttachment[]): Promise<string> {
+  let translated = text;
+  try {
+    const names = await loadAgentNames();
+    if (names.length > 0) translated = translateAgentMentions(text, names).text;
+  } catch {
+    // keep the raw prompt
+  }
+  // File mentions are namespaced (`@file:`) by the picker; strip the namespace
+  // only after the agent pass so `@file:<name>` is never mistaken for `@agent`.
+  return composeMessageWithTextAttachments(translateFileMentions(translated), textFiles);
+}

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

@@ -15,33 +15,13 @@ import type { Dispatch, SetStateAction } from 'preact/compat';
 import type { Attachment, ChatMessageData, OmpAgentHandle, QueuedMessageModel } from '@/shared/types';
 import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { streamChatResponse } from '@/client/hooks/chat/stream';
-import { composeMessageWithTextAttachments, isTextAttachmentFile } from '@/shared/lib/chat/attachments';
-import { loadAgentNames } from '@/shared/lib/chat/composer/client';
-import { translateAgentMentions, translateFileMentions } from '@/shared/lib/chat/composer/translate';
+import type { SessionSeed } from '@/client/hooks/chat/timeline/session-load';
+import { buildPromptText } from '@/client/hooks/chat/timeline/prompt-text';
+import { isTextAttachmentFile } from '@/shared/lib/chat/attachments';
 import { createMockStreamCallbacks } from '@/shared/lib/chat/timeline/stream-callbacks';
 import { PHASE_VERBS } from '@/shared/lib/chat/timeline/tool-phrases';
 import { formatClock } from '@/shared/lib/format/time';
 
-type TextFileAttachment = Parameters<typeof composeMessageWithTextAttachments>[1][number];
-
-/**
- * Build the outgoing prompt. `@agent` mentions are rewritten into an explicit
- * task-tool delegation directive at send time (oh-my-pi has no `@agent`
- * syntax); translation failures fall back to the raw prompt.
- */
-async function buildPromptText(text: string, textFiles: TextFileAttachment[]): Promise<string> {
-  let translated = text;
-  try {
-    const names = await loadAgentNames();
-    if (names.length > 0) translated = translateAgentMentions(text, names).text;
-  } catch {
-    // keep the raw prompt
-  }
-  // File mentions are namespaced (`@file:`) by the picker; strip the namespace
-  // only after the agent pass so `@file:<name>` is never mistaken for `@agent`.
-  return composeMessageWithTextAttachments(translateFileMentions(translated), textFiles);
-}
-
 export interface ChatTimelineSendDeps {
   folders: any[];
   selectedFolderId: number | null;
@@ -61,7 +41,9 @@ export interface ChatTimelineSendDeps {
   adoptedSessionIdRef: { current: string | null };
   optimisticUserIdRef: { current: string | null };
   pendingUserDisplaysRef: { current: { sent: string; display: string }[] };
-  setSessionModel: (model: { provider: string; modelId: string } | null) => void;
+  /** Adopt the spawned session's identity (model + the thinking level the first
+   *  prompt runs with) so the composer replacing the pending view shows it. */
+  seedSession: (seed: SessionSeed) => void;
   /** Model/thinking picked in the composer before the session existed —
    *  applied to the spawn command so the first prompt runs with them. */
   pendingComposerModelRef: { current: { provider: string; modelId: string } | null };
@@ -106,7 +88,7 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
     adoptedSessionIdRef,
     optimisticUserIdRef,
     pendingUserDisplaysRef,
-    setSessionModel,
+    seedSession,
     pendingComposerModelRef,
     pendingThinkingLevelRef,
     accessModeRef,
@@ -291,7 +273,11 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
         if (spawned) {
           adoptedSessionIdRef.current = spawned.sessionId;
           aiPlaceholderIdRef.current = aiPlaceholderId;
-          if (spawned.model) setSessionModel(spawned.model);
+          // The spawn already applied this level to the session; seed it so the
+          // composer taking over from the pending view reports the run's real
+          // setting instead of a catalog default (the JSONL that carries it is
+          // not locatable yet).
+          seedSession({ model: spawned.model, thinkingLevel: composerThinking });
           pendingComposerModelRef.current = null;
           pendingThinkingLevelRef.current = null;
           fetch(`/api/chat/${encodeURIComponent(spawned.sessionId)}`, {
@@ -304,8 +290,9 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
             next.set('sessionId', spawned.sessionId);
             return next;
           }, { replace: true });
-          // The agent_start event refreshes the session metadata/sidebar once
-          // the JSONL has the user turn; no immediate refresh is needed here.
+          // The sidebar already re-read at prompt dispatch (sendNewPrompt
+          // signals it), so the new session shows its live badge without
+          // waiting for the JSONL to carry the user turn.
           return;
         }
       }
@@ -342,6 +329,6 @@ export function useChatTimelineSend(deps: ChatTimelineSendDeps): ChatTimelineSen
         scrollToBottom,
       })
     );
-  }, [appSettings, folders, isOmpSession, ompAgent, selectedFolderId, sessionId, scrollToBottom, jumpToBottom, persistMessages, setSessionModel, pendingComposerModelRef, pendingThinkingLevelRef, accessModeRef]);
+  }, [appSettings, folders, isOmpSession, ompAgent, selectedFolderId, sessionId, scrollToBottom, jumpToBottom, persistMessages, seedSession, pendingComposerModelRef, pendingThinkingLevelRef, accessModeRef]);
   return { steerOmpAgent, executeSend };
 }