ompchamber 0.6.0 → 0.8.0

package/src/client/components/workspace/chat-timeline/tool-renderers/ask-panel/drafts.ts

@@ -0,0 +1,113 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Answer bookkeeping for the inline ask card.
+ *
+ * omp asks a multi-question `ask` one question at a time and blocks on each, so
+ * only the question currently in flight owns a dialog. The card still lets the
+ * user answer any of them, in any order: a choice made for a question omp has
+ * not reached yet is held here and released the moment its dialog arrives. Every
+ * sent dialog is remembered by id, so a re-render (or a replayed request after a
+ * page reload) can never answer the same frame twice.
+ *
+ * Multi-select questions are excluded from that queue: omp re-asks them once per
+ * toggle and only the LAST one settles the question, so each click is sent
+ * immediately and only the display state accumulates here.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+import type { AskAnswer, AskQuestion } from '@/shared/lib/chat/ask-questions';
+import type { ExtensionDialogResponse } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/Lazy';
+
+interface UseAskDraftsOptions {
+  toolId: string;
+  questions: AskQuestion[];
+  /** Dialogs per question, oldest first — the last one is the live dialog. */
+  groups: ExtensionUiDialogRequest[][];
+  /** Answers omp already recorded in the tool result, per question. */
+  recorded: (AskAnswer | null)[];
+  respond: (request: ExtensionUiDialogRequest, response: ExtensionDialogResponse) => void;
+}
+
+export interface AskDrafts {
+  /** Committed single-choice answers, by question index. */
+  drafts: Record<number, string>;
+  /** Labels the user has toggled on a multi-select question, for display only. */
+  multiSelected: Record<number, string[]>;
+  commit: (index: number, value: string) => void;
+  toggleMulti: (index: number, label: string) => void;
+}
+
+/** The live dialog for a question: the most recent frame it raised. */
+export function liveFrame(groups: ExtensionUiDialogRequest[][], index: number): ExtensionUiDialogRequest | null {
+  const frames = groups[index];
+  return frames && frames.length > 0 ? frames[frames.length - 1] : null;
+}
+
+// omp records answers only in the FINAL tool result, so a reload mid-ask would
+// otherwise repaint every question already answered as still waiting. The draft
+// cache keeps the text across a reload; it is per-tab and dies with the session.
+function draftKey(toolId: string): string {
+  return `ompchamber.ask-draft:${toolId}`;
+}
+
+function loadDrafts(toolId: string): Record<number, string> {
+  try {
+    const raw = sessionStorage.getItem(draftKey(toolId));
+    return raw ? (JSON.parse(raw) as Record<number, string>) : {};
+  } catch {
+    return {};
+  }
+}
+
+export function useAskDrafts({ toolId, questions, groups, recorded, respond }: UseAskDraftsOptions): AskDrafts {
+  const [drafts, setDrafts] = useState<Record<number, string>>(() => loadDrafts(toolId));
+  const [multiSelected, setMultiSelected] = useState<Record<number, string[]>>({});
+  const sentRef = useRef<Set<string>>(new Set());
+
+  useEffect(() => {
+    for (let index = 0; index < questions.length; index += 1) {
+      if (recorded[index] || questions[index].multi) continue;
+      const value = drafts[index];
+      if (!value) continue;
+      const frame = liveFrame(groups, index);
+      if (!frame || frame.method !== 'select' || sentRef.current.has(frame.id)) continue;
+      sentRef.current.add(frame.id);
+      respond(frame, { value });
+    }
+  }, [questions, groups, drafts, recorded, respond]);
+
+  useEffect(() => {
+    try {
+      sessionStorage.setItem(draftKey(toolId), JSON.stringify(drafts));
+    } catch {
+      // Storage disabled (private mode): the card still works for this mount.
+    }
+  }, [toolId, drafts]);
+
+  const commit = useCallback((index: number, value: string) => {
+    setDrafts((current) => (current[index] === value ? current : { ...current, [index]: value }));
+  }, []);
+
+  const toggleMulti = useCallback((index: number, label: string) => {
+    const frame = liveFrame(groups, index);
+    if (!frame || sentRef.current.has(frame.id)) return;
+    // One omp dialog per toggle: answering it re-asks the question with the
+    // updated set, so the next click lands on the dialog that just arrived.
+    sentRef.current.add(frame.id);
+    respond(frame, { value: label });
+    setMultiSelected((current) => {
+      const selected = current[index] ?? [];
+      return {
+        ...current,
+        [index]: selected.includes(label) ? selected.filter((item) => item !== label) : [...selected, label],
+      };
+    });
+  }, [groups, respond]);
+
+  return { drafts, multiSelected, commit, toggleMulti };
+}

package/src/client/components/workspace/chat-timeline/tool-renderers/ask-panel/index.tsx

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Inline card for omp's `ask` tool — the whole conversation with the user, in
+ * the timeline instead of a modal.
+ *
+ * omp asks one question per dialog and blocks on it, so a modal could only ever
+ * show the question in flight and lost every earlier one on the way; the card
+ * keeps all of them in view, marks the ones already answered, and ends as the
+ * summary of what the agent asked and what it was told.
+ */
+
+import { HelpCircle, XCircle } from 'lucide-preact';
+import type { ToolCallData } from '@/shared/types';
+import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
+import { parseAskQuestions, parseAskResult } from '@/shared/lib/chat/ask-questions';
+import { useAskFrames } from '@/client/hooks/chat/timeline/ask-frames';
+import { liveFrame, useAskDrafts } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-panel/drafts';
+import { QuestionBlock } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-panel/QuestionBlock';
+import { FallbackOutput } from '@/client/components/workspace/chat-timeline/tool-renderers/shared/FallbackOutput';
+
+// Stable empties: fresh `[]` literals would defeat the question block's props.
+const NO_FRAMES: ExtensionUiDialogRequest[] = [];
+const NO_GROUPS: ExtensionUiDialogRequest[][] = [];
+const NO_LABELS: string[] = [];
+
+export function AskPanel({ tool }: { tool: ToolCallData }) {
+  const questions = parseAskQuestions(tool);
+  const recorded = parseAskResult(tool, questions);
+  const { framesByTool, respond } = useAskFrames();
+  const groups = framesByTool.get(tool.id) ?? NO_GROUPS;
+  const { drafts, multiSelected, commit, toggleMulti } = useAskDrafts({
+    toolId: tool.id,
+    questions,
+    groups,
+    recorded,
+    respond,
+  });
+
+  // An `ask` whose arguments the timeline never saw (or a non-questions shape)
+  // still has a result worth showing.
+  if (questions.length === 0) {
+    return tool.output ? <FallbackOutput text={tool.output} /> : null;
+  }
+
+  const waiting = groups.some((frames, index) => frames.length > 0 && !recorded[index]);
+  // omp asks in order and blocks on each, so the earliest question holding a
+  // dialog is the only open one: everything before it is answered, whether or
+  // not this client still has the text.
+  const askingIndex = groups.findIndex((frames) => frames.length > 0);
+
+  return (
+    <div className="space-y-2">
+      {waiting && (
+        <div className="flex items-center gap-1.5 text-[10.5px] text-ink/50">
+          <HelpCircle size={11} className="shrink-0" />
+          <span>Input needed — the agent is blocked until you answer.</span>
+        </div>
+      )}
+
+      {questions.map((question, index) => (
+        <QuestionBlock
+          key={question.id ?? index}
+          index={index}
+          total={questions.length}
+          question={question}
+          frames={groups[index] ?? NO_FRAMES}
+          recorded={recorded[index] ?? null}
+          draft={drafts[index]}
+          passed={askingIndex !== -1 && index < askingIndex}
+          multiSelected={multiSelected[index] ?? NO_LABELS}
+          onAnswer={(value) => commit(index, value)}
+          onToggle={(label) => toggleMulti(index, label)}
+          onRespond={(response) => {
+            const frame = liveFrame(groups, index);
+            if (frame) respond(frame, response);
+          }}
+        />
+      ))}
+
+      {(tool.status === 'error' || tool.status === 'aborted') && tool.output && (
+        <div className="flex items-start gap-2 rounded-md border border-ink/8 bg-ink/[0.02] px-2.5 py-1.5 text-[10.5px] text-ink/60">
+          <XCircle size={11} className="mt-0.5 shrink-0 text-ink/40" />
+          <span className="font-mono select-text">{tool.output}</span>
+        </div>
+      )}
+    </div>
+  );
+}

package/src/client/components/workspace/chat-timeline/tool-renderers/{ask-dialog → extension-dialog}/Footer.tsx

@@ -1,6 +1,6 @@
 import { CornerDownLeft, X } from 'lucide-preact';
 
-interface AskDialogFooterProps {
+interface ExtensionDialogFooterProps {
   method: string;
   optionsLength: number;
   selectedOption: string | null;
@@ -9,14 +9,14 @@ interface AskDialogFooterProps {
   onSubmit: () => void;
 }
 
-export function AskDialogFooter({
+export function ExtensionDialogFooter({
   method,
   optionsLength,
   selectedOption,
   hasCustomAnswer = false,
   onCancel,
   onSubmit,
-}: AskDialogFooterProps) {
+}: ExtensionDialogFooterProps) {
   const isSelectDisabled = method === 'select' && !selectedOption && !hasCustomAnswer;
 
   return (

package/src/client/components/workspace/chat-timeline/tool-renderers/{ask-dialog → extension-dialog}/Header.tsx

@@ -1,7 +1,7 @@
 import type { ReactNode } from 'preact/compat';
 import { Sparkles, X } from 'lucide-preact';
 
-interface AskDialogHeaderProps {
+interface ExtensionDialogHeaderProps {
   title?: string;
   methodLabel: string;
   badge: string;
@@ -9,13 +9,13 @@ interface AskDialogHeaderProps {
   onCancel: () => void;
 }
 
-export function AskDialogHeader({
+export function ExtensionDialogHeader({
   title,
   methodLabel,
   badge,
   icon,
   onCancel,
-}: AskDialogHeaderProps) {
+}: ExtensionDialogHeaderProps) {
   return (
     <div className="flex items-center justify-between border-b border-ink/8 bg-canvas/40 px-5 py-3.5">
       <div className="flex items-center gap-3 min-w-0">

package/src/client/components/workspace/chat-timeline/tool-renderers/{ask-dialog → extension-dialog}/Lazy.tsx

@@ -1,24 +1,24 @@
 import { Suspense, lazy } from 'preact/compat';
 import type { ExtensionUiDialogRequest } from '@/client/hooks/chat/omp';
-import type { ExtensionDialogResponse } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-dialog/index';
+import type { ExtensionDialogResponse } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/index';
 
-const AskDialogImpl = lazy(() =>
-  import('@/client/components/workspace/chat-timeline/tool-renderers/ask-dialog/index').then((m) => ({
-    default: m.AskDialog,
+const ExtensionDialogImpl = lazy(() =>
+  import('@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/index').then((m) => ({
+    default: m.ExtensionDialog,
   }))
 );
 
-interface AskDialogProps {
+interface ExtensionDialogProps {
   request: ExtensionUiDialogRequest;
   onRespond: (request: ExtensionUiDialogRequest, response: ExtensionDialogResponse) => void;
 }
 
-export function AskDialog(props: AskDialogProps) {
+export function ExtensionDialog(props: ExtensionDialogProps) {
   return (
     <Suspense fallback={null}>
-      <AskDialogImpl {...props} />
+      <ExtensionDialogImpl {...props} />
     </Suspense>
   );
 }
 
-export type { ExtensionDialogResponse } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-dialog/index';
+export type { ExtensionDialogResponse } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/index';

package/src/client/components/workspace/chat-timeline/tool-renderers/{ask-dialog → extension-dialog}/SelectBody.tsx

@@ -1,7 +1,7 @@
 import type { RefObject } from 'preact/compat';
 import { CheckCircle2, Circle } from 'lucide-preact';
 
-interface AskDialogSelectBodyProps {
+interface ExtensionDialogSelectBodyProps {
   options: string[];
   optionDetails: { description?: string }[];
   selectedOption: string | null;
@@ -12,7 +12,7 @@ interface AskDialogSelectBodyProps {
   onConfirmOption: (option: string) => void;
 }
 
-export function AskDialogSelectBody({
+export function ExtensionDialogSelectBody({
   options,
   optionDetails,
   selectedOption,
@@ -21,7 +21,7 @@ export function AskDialogSelectBody({
   customInputRef,
   onSelect,
   onConfirmOption,
-}: AskDialogSelectBodyProps) {
+}: ExtensionDialogSelectBodyProps) {
   return (
     <div className="space-y-2">
       <div className="flex items-center justify-between text-[11px] font-medium tracking-wider text-ink/50 uppercase">

package/src/client/components/workspace/chat-timeline/tool-renderers/{ask-dialog → extension-dialog}/index.tsx

@@ -2,9 +2,9 @@
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 import { AlertCircle, CheckCircle2, FileText, HelpCircle, ListFilter, Terminal } from 'lucide-preact';
 import type { ExtensionUiDialogRequest } from '@/client/hooks/chat/omp';
-import { AskDialogHeader } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-dialog/Header';
-import { AskDialogSelectBody } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-dialog/SelectBody';
-import { AskDialogFooter } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-dialog/Footer';
+import { ExtensionDialogHeader } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/Header';
+import { ExtensionDialogSelectBody } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/SelectBody';
+import { ExtensionDialogFooter } from '@/client/components/workspace/chat-timeline/tool-renderers/extension-dialog/Footer';
 import { MarkdownRenderer } from '@/client/components/common/MarkdownRenderer';
 
 export type ExtensionDialogResponse =
@@ -12,12 +12,18 @@ export type ExtensionDialogResponse =
   | { confirmed: boolean }
   | { cancelled: true };
 
-interface AskDialogProps {
+interface ExtensionDialogProps {
   request: ExtensionUiDialogRequest;
   onRespond: (request: ExtensionUiDialogRequest, response: ExtensionDialogResponse) => void;
 }
 
-export function AskDialog({ request, onRespond }: AskDialogProps) {
+/**
+ * Blocking extension dialog that has no card of its own to render in: an
+ * approval gate under `always-ask`, or a picker an extension raised. The `ask`
+ * tool's own dialogs render inline on its tool card instead (see ask-panel) —
+ * a modal would only ever show the question currently in flight.
+ */
+export function ExtensionDialog({ request, onRespond }: ExtensionDialogProps) {
   const [value, setValue] = useState(request.method === 'editor' ? request.prefill ?? '' : '');
   const [selectedOption, setSelectedOption] = useState<string | null>(null);
   const [customValue, setCustomValue] = useState('');
@@ -202,7 +208,7 @@ export function AskDialog({ request, onRespond }: AskDialogProps) {
 
   return (
     <div
-      className="ask-dialog-backdrop fixed inset-0 z-50 flex items-center justify-center p-4 sm:p-6"
+      className="extension-dialog-backdrop fixed inset-0 z-50 flex items-center justify-center p-4 sm:p-6"
       style={{
         background: 'color-mix(in srgb, var(--theme-ink) 55%, transparent)',
         backdropFilter: 'blur(8px)',
@@ -217,12 +223,12 @@ export function AskDialog({ request, onRespond }: AskDialogProps) {
         aria-modal="true"
         aria-label={request.title || methodMeta.label}
         tabIndex={-1}
-        className="ask-dialog-panel w-full max-w-[560px] overflow-hidden rounded-2xl border border-ink/15 bg-paper shadow-2xl outline-none"
+        className="extension-dialog-panel w-full max-w-[560px] overflow-hidden rounded-2xl border border-ink/15 bg-paper shadow-2xl outline-none"
         style={{
           boxShadow: '0 24px 64px -8px color-mix(in srgb, var(--theme-ink) 28%, transparent)',
         }}
       >
-          <AskDialogHeader
+          <ExtensionDialogHeader
             title={request.title}
             methodLabel={methodMeta.label}
             badge={methodMeta.badge}
@@ -240,7 +246,7 @@ export function AskDialog({ request, onRespond }: AskDialogProps) {
 
             {/* Select Options */}
             {request.method === 'select' && (
-              <AskDialogSelectBody
+              <ExtensionDialogSelectBody
                 options={options}
                 optionDetails={optionDetails}
                 selectedOption={selectedOption}
@@ -307,7 +313,7 @@ export function AskDialog({ request, onRespond }: AskDialogProps) {
             )}
           </div>
 
-          <AskDialogFooter
+          <ExtensionDialogFooter
             method={request.method}
             optionsLength={options.length}
             selectedOption={selectedOption}

package/src/client/components/workspace/chat-timeline/tool-renderers/index.tsx

@@ -19,7 +19,7 @@ import { AstEdit } from '@/client/components/workspace/chat-timeline/tool-render
 import { Resolve } from '@/client/components/workspace/chat-timeline/tool-renderers/panels/Resolve';
 import { ManageSkill } from '@/client/components/workspace/chat-timeline/tool-renderers/panels/ManageSkill';
 import { SearchFs } from '@/client/components/workspace/chat-timeline/tool-renderers/panels/SearchFs';
-import { Ask } from '@/client/components/workspace/chat-timeline/tool-renderers/panels/Ask';
+import { AskPanel } from '@/client/components/workspace/chat-timeline/tool-renderers/ask-panel';
 import { Think } from '@/client/components/workspace/chat-timeline/tool-renderers/panels/Think';
 import { Read } from '@/client/components/workspace/chat-timeline/tool-renderers/panels/Read';
 import { Edit } from '@/client/components/workspace/chat-timeline/tool-renderers/panels/Edit';
@@ -142,7 +142,7 @@ export function ToolDetailsPanel({ tool }: { tool: ToolCallData }): ReactNode {
     return <Memory tool={tool} />;
   }
   if (key === 'goal' || key === 'yield') return <Goal tool={tool} />;
-  if (key === 'ask') return <Ask tool={tool} />;
+  if (key === 'ask') return <AskPanel tool={tool} />;
   if (key === 'think') return <Think tool={tool} />;
 
   // Dynamic MCP / custom tools — `mcp__<tool>` names and xd:// device writes

package/src/client/components/workspace/file-explorer/index.tsx

@@ -63,15 +63,28 @@ export function FileExplorer({ className = '', enabled = true, rootPath, onOpenF
     loadFiles();
   }, [refreshKey, rootPath, enabled, activeRepo, expandedPathsReady]);
 
-  // Auto refresh: re-read the directory tree on a cadence so external changes
-  // (terminal output, agent edits) surface without a manual refresh. Silent —
-  // the loading spinner stays reserved for the user's own refresh button.
-  usePanelRefresh(() => loadFiles({ silent: true }), enabled && expandedPathsReady);
+  // The listing and its git decorations describe the same working tree, so one
+  // refresh drives both. Re-reading only the tree left every folder dot stale:
+  // `useGitStatus` has no poll of its own in this panel, so a new/changed file
+  // appeared under a folder that still claimed a clean status until the user
+  // hit refresh or refocused the window.
+  const refreshListing = () => {
+    loadFiles({ silent: true });
+    refreshGitStatus();
+  };
+  // Auto refresh: re-read on a cadence so external changes (terminal output,
+  // agent edits) surface without a manual refresh. Silent — the loading
+  // spinner stays reserved for the user's own refresh button.
+  usePanelRefresh(refreshListing, enabled && expandedPathsReady);
   // AI edits land between poll ticks: re-read right after a file-mutating tool
   // (edit / write / ast_edit / bash) finishes, not up to 2s later.
-  useFileMutationRefresh(() => loadFiles({ silent: true }), enabled && expandedPathsReady);
+  useFileMutationRefresh(refreshListing, enabled && expandedPathsReady);
 
   const loadChildren = (path: string) => {
+    // Expanding IS a directory load: fetch the children AND re-read git status,
+    // so a freshly listed row never renders bare next to a status map that
+    // still predates its change (the panel poll alone can lag a fresh edit).
+    refreshGitStatus();
     return fetch(listUrl(path))
       .then(r => r.json())
       .then(data => {

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

@@ -1,8 +1,8 @@
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 import type { ChatMessageData, OmpAgentCallbacks, OmpAgentHandle, OmpAgentState, StreamTransport } from '@/shared/types';
 import type { ExtensionUiDialogRequest } from '@/shared/types/omp/agent';
-import type { ApprovalMode } from '@/shared/lib/omp/config/access-mode';
 import { type ToolResultRecord, useOmpAgentStream } from '@/client/hooks/chat/omp/stream';
+import { useOmpPromptSender } from '@/client/hooks/chat/omp/prompt-send';
 import { stopAgentSession } from '@/shared/lib/chat/omp/abort';
 
 /**
@@ -98,114 +98,9 @@ export function useOmpAgent(sessionId: string | null, callbacks: OmpAgentCallbac
     };
   }, [sessionId, disconnect, connect]);
 
-  /** 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;
-      }
-      return true;
-    } catch (e) {
-      setState((prev) => ({ ...prev, isGenerating: false, error: e instanceof Error ? e.message : String(e) }));
-      return false;
-    }
-  }, [connect]);
-
-  /** 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;
-      }
-      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]);
+  // Prompt delivery (warm-up + stream attach + the dispatch-time sidebar
+  // signal) lives in its own module so this hook stays under the size ceiling.
+  const { sendPrompt, sendNewPrompt } = useOmpPromptSender({ sessionIdRef, connect, setState });
 
   /** Abort the running agent turn. */
   const abort = useCallback(async () => {