ompchamber 0.7.0 → 1.0.0

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,
@@ -177,20 +177,20 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
 
   const {
     messageQueue,
-    setMessageQueue,
+    enqueueMessage,
+    removeMessage,
+    reorderMessages,
     steeringQueue,
     setSteeringQueue,
-    removeDeliveredFromQueue,
   } = useChatTimelineQueue(sessionId);
   const {
-    dialog: extensionDialog,
+    pending: extensionDialogs,
     enqueue: enqueueExtensionDialog,
-    dismiss: dismissExtensionDialog,
+    resolve: resolveExtensionDialog,
     withdraw: withdrawExtensionDialog,
   } = useExtensionDialogQueue(sessionId);
 
   const ompAgent = useOmpAgent(isOmpSession ? sessionId : null, createOmpAgentCallbacks({
-    removeDeliveredFromQueue,
     setGenerating,
     setGeneratingVerb,
     scrollToBottom,
@@ -226,7 +226,7 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     adoptedSessionIdRef,
     optimisticUserIdRef,
     pendingUserDisplaysRef,
-    setSessionModel,
+    seedSession,
     pendingComposerModelRef,
     pendingThinkingLevelRef,
     composerModelRef,
@@ -236,21 +236,11 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     setSearchParams,
   });
 
-  // Auto-process queue: when the run ends (or was never active), deliver the
-  // head item. Both modes queue client-side now — omp sends it as a normal
-  // prompt via executeSend (which routes to the omp bridge); the mock path
-  // streams the same way. A user Stop arms `stopHoldRef`: the run ends but the
-  // queue stays put (stop-all semantics — the toast offers Send now); the next
-  // explicit send disarms it.
-  useEffect(() => {
-    if (stopHoldRef.current) return;
-    if (!isGenerating && messageQueue.length > 0) {
-      const nextMessage = messageQueue[0];
-      setMessageQueue(q => q.slice(1));
-      // The queued snapshot re-applies model/thinking/access before the prompt.
-      executeSend(nextMessage.text, nextMessage.attachments, { model: nextMessage.model });
-    }
-  }, [isGenerating, messageQueue, executeSend, setMessageQueue]);
+  // Queue auto-delivery moved server-side: the wrapper's terminal `agent_end`
+  // schedules the next queued prompt (`lib/queue/delivery.server.ts`), with a
+  // transactional head claim so no reload/tab race can double-send or wipe the
+  // table. The client panel is a view; the mount nudge lives in the queue
+  // hook. `stopHoldRef` remains only for the mock path below.
 
   const {
     handleSend,
@@ -262,7 +252,6 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     stopGenerating,
     handleThinkingLevelChange,
     handleModelChange,
-    closeExtensionDialog,
   } = useChatTimelineActions({
     inputValue,
     setInputValue,
@@ -272,7 +261,8 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     sessionId,
     appSettings,
     messageQueue,
-    setMessageQueue,
+    enqueueMessage,
+    removeMessage,
     executeSend,
     steerOmpAgent,
     ompAgent,
@@ -286,7 +276,6 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     composerModelRef,
     accessModeRef,
     setSearchParams,
-    dismissExtensionDialog,
   });
 
   return {
@@ -305,7 +294,8 @@ export function useChatTimeline({ folders = [], appSettings = {} }: UseChatTimel
     loadOlder,
     generatingVerb,
     messageQueue,
-    setMessageQueue,
+    removeMessage,
+    reorderMessages,
     steeringQueue,
     setSteeringQueue,
     inputValue,
@@ -331,8 +321,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/queue.ts

@@ -4,84 +4,148 @@
  */
 
 /**
- * Follow-up + steering queue state for the chamber chat, backed by the SQLite
- * `queued_messages` table via /api/sessions/:id/queue (one row per item with a
- * model snapshot, so auto-delivery replays the settings the item was queued
- * with).
+ * Client view of the follow-up queue (SQLite `queued_messages`, owned by the
+ * server). The panel is a VIEW: mutations go through the per-item endpoints
+ * (`POST/PATCH/DELETE /api/sessions/:id/queue[/:itemId]`) and every response
+ * carries the canonical queue, which replaces local state wholesale. The old
+ * client-side replace-on-write mirror is gone — it was what let a reload
+ * hydrating over an empty state wipe the table, and a session switch PUT one
+ * session's list into another's rows.
  *
- * The client panel stays the source of truth while the session is open: every
- * mutation updates React state first, then PUTs the full remaining list to the
- * route (replace-on-write keeps ids stable for reorder/edit/delete). The queue
- * hydrates from the table on mount — a page reload mid-stream restores it.
- * Steering mirrors live in the session-state blob under a separate key.
- *
- * Kept out of useChatTimeline so that hook stays under the size ceiling.
+ * Steering still mirrors into the per-session session-state blob (client-only
+ * by design: an interrupt-and-reply is only meaningful while a client watches
+ * the run).
  */
 
-import type { SetStateAction } from 'preact/compat';
 import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 import type { QueuedMessage } from '@/shared/types';
 import { useSessionState } from '@/client/hooks/workspace/session-state';
 
 const STEERING_STATE_KEY = 'chat.steeringQueue';
 
+function queueUrl(sessionId: string): string {
+  return `/api/sessions/${encodeURIComponent(sessionId)}/queue`;
+}
+
+async function readQueueResponse(res: Response): Promise<QueuedMessage[] | null> {
+  if (!res.ok) return null;
+  const data = (await res.json().catch(() => null)) as { queue?: unknown } | null;
+  return Array.isArray(data?.queue) ? (data.queue as QueuedMessage[]) : null;
+}
+
 export interface ChatTimelineQueueResult {
   messageQueue: QueuedMessage[];
-  setMessageQueue: (updater: SetStateAction<QueuedMessage[]>) => void;
+  /** Append one item; local state updates optimistically, then reconciles
+   *  from the canonical response. No-op without a session. */
+  enqueueMessage: (item: Omit<QueuedMessage, 'id'>) => void;
+  /** Edit one item's text (PATCH). */
+  editMessageText: (id: string, text: string) => void;
+  /** Remove one item by id (DELETE). */
+  removeMessage: (id: string) => void;
+  /** Reorder the queue to these ids (PUT, drag-and-drop). */
+  reorderMessages: (orderedIds: string[]) => void;
+  /** Replace the local list from a fetch (mount hydration, manual refresh). */
+  refresh: () => void;
+  /** Client-only steering mirror (session-state blob). */
   steeringQueue: QueuedMessage[];
-  setSteeringQueue: (updater: SetStateAction<QueuedMessage[]>) => void;
-  /** Drop an exactly-matching text from whichever mirror queue holds it. */
-  removeDeliveredFromQueue: (text: string) => void;
+  setSteeringQueue: (value: QueuedMessage[] | ((prev: QueuedMessage[]) => QueuedMessage[])) => void;
 }
 
 export function useChatTimelineQueue(sessionId: string | null): ChatTimelineQueueResult {
   const [messageQueue, setMessageQueueState] = useState<QueuedMessage[]>([]);
   const [steeringQueue, setSteeringQueue] = useSessionState<QueuedMessage[]>(STEERING_STATE_KEY, []);
 
-  // Hydrate from the table once per session. A generation-safe ref skips the
-  // stale-response race when the user switches sessions quickly.
+  // Hydrate from the table once per session, and re-read when the tab
+  // regains focus (a second tab may have claimed/delivered the head). A
+  // generation-safe ref skips the stale-response race on quick switches.
   const hydrateEpochRef = useRef(0);
-  useEffect(() => {
+  const cancelledRef = useRef(false);
+  const refresh = useCallback(() => {
     if (!sessionId) {
       setMessageQueueState([]);
       return;
     }
     const epoch = ++hydrateEpochRef.current;
-    let cancelled = false;
-    fetch(`/api/sessions/${encodeURIComponent(sessionId)}/queue`)
-      .then(res => (res.ok ? res.json() : { queue: [] }))
-      .then((data: { queue?: QueuedMessage[] }) => {
-        if (cancelled || hydrateEpochRef.current !== epoch) return;
-        setMessageQueueState(Array.isArray(data.queue) ? data.queue : []);
+    fetch(queueUrl(sessionId))
+      .then((res) => readQueueResponse(res))
+      .then((queue) => {
+        if (cancelledRef.current || hydrateEpochRef.current !== epoch) return;
+        setMessageQueueState(queue ?? []);
       })
       .catch(() => {});
-    return () => { cancelled = true; };
   }, [sessionId]);
+  useEffect(() => {
+    cancelledRef.current = false;
+    refresh();
+    const onFocus = () => refresh();
+    window.addEventListener('focus', onFocus);
+    return () => {
+      cancelledRef.current = true;
+      window.removeEventListener('focus', onFocus);
+    };
+  }, [refresh]);
 
-  // Replace-on-write mirror: every client mutation PUTs the full list so the
-  // table always matches the panel (order, edits, deletions included).
-  const mirrorQueue = useCallback((next: QueuedMessage[]) => {
+  // Mounted session with queued items: offer the server a delivery slot. The
+  // server-side claim makes this harmless when a run is active or another tab
+  // already took the head — this used to be the client auto-delivery effect,
+  // which fired into whatever session was open at the time.
+  useEffect(() => {
+    if (!sessionId || messageQueue.length === 0) return;
+    fetch(`${queueUrl(sessionId)}/deliver`, { method: 'POST' }).catch(() => {});
+  }, [sessionId, messageQueue.length > 0]);
+
+  const enqueueMessage = useCallback((item: Omit<QueuedMessage, 'id'>) => {
     if (!sessionId) return;
-    fetch(`/api/sessions/${encodeURIComponent(sessionId)}/queue`, {
-      method: 'PUT',
+    const optimistic: QueuedMessage = { ...item, id: `queue-${Date.now()}` };
+    setMessageQueueState((prev) => [...prev, optimistic]);
+    fetch(queueUrl(sessionId), {
+      method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ queue: next }),
-    }).catch(console.error);
+      body: JSON.stringify(item),
+    })
+      .then((res) => readQueueResponse(res))
+      .then((queue) => { if (queue) setMessageQueueState(queue); })
+      .catch(() => {});
   }, [sessionId]);
 
-  const setMessageQueue = useCallback((updater: SetStateAction<QueuedMessage[]>) => {
-    setMessageQueueState(prev => {
-      const next = typeof updater === 'function' ? updater(prev) : updater;
-      mirrorQueue(next);
-      return next;
-    });
-  }, [mirrorQueue]);
+  const editMessageText = useCallback((id: string, text: string) => {
+    if (!sessionId) return;
+    fetch(`${queueUrl(sessionId)}/${encodeURIComponent(id)}`, {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text }),
+    })
+      .then((res) => readQueueResponse(res))
+      .then((queue) => { if (queue) setMessageQueueState(queue); })
+      .catch(() => {});
+  }, [sessionId]);
+
+  const removeMessage = useCallback((id: string) => {
+    if (!sessionId) return;
+    // Optimistic removal, reconciled only on failure (404 = already claimed —
+    // the item is gone either way).
+    setMessageQueueState((prev) => prev.filter((i) => i.id !== id));
+    fetch(`${queueUrl(sessionId)}/${encodeURIComponent(id)}`, { method: 'DELETE' })
+      .then((res) => readQueueResponse(res))
+      .then((queue) => { if (queue) setMessageQueueState(queue); })
+      .catch(() => {});
+  }, [sessionId]);
 
-  const removeDeliveredFromQueue = useCallback((text: string) => {
-    const exact = (q: QueuedMessage[]) => q.some(i => i.text === text);
-    setSteeringQueue(q => (exact(q) ? q.filter(i => i.text !== text) : q));
-    setMessageQueue(q => (exact(q) ? q.filter(i => i.text !== text) : q));
-  }, [setSteeringQueue, setMessageQueue]);
+  const reorderMessages = useCallback((orderedIds: string[]) => {
+    if (!sessionId) return;
+    setMessageQueueState((prev) => {
+      const byId = new Map(prev.map((i) => [i.id, i]));
+      return orderedIds.map((id) => byId.get(id)).filter((i): i is QueuedMessage => Boolean(i));
+    });
+    fetch(queueUrl(sessionId), {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ orderedIds }),
+    })
+      .then((res) => readQueueResponse(res))
+      .then((queue) => { if (queue) setMessageQueueState(queue); })
+      .catch(() => {});
+  }, [sessionId]);
 
-  return { messageQueue, setMessageQueue, steeringQueue, setSteeringQueue, removeDeliveredFromQueue };
+  return { messageQueue, enqueueMessage, editMessageText, removeMessage, reorderMessages, refresh, steeringQueue, setSteeringQueue };
 }

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)}`, {
@@ -343,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 };
 }