ompchamber 0.7.0 → 0.8.0

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

package/src/client/hooks/chat/timeline/session-load.ts

@@ -18,10 +18,11 @@
  */
 
 import type { Dispatch, RefObject, SetStateAction } from 'preact/compat';
-import { useCallback, useEffect, useLayoutEffect, useRef, useState } from 'preact/hooks';
+import { useCallback, useEffect, useRef, useState } from 'preact/hooks';
 
 import type { ChatMessageData } from '@/shared/types';
 import { SESSION_META_RETRY_SCHEDULE_MS } from '@/shared/lib/workspace/refresh-cadence';
+import { useSessionPagination } from '@/client/hooks/chat/timeline/session-pagination';
 
 export interface SessionDataShape {
   id?: string;
@@ -31,6 +32,12 @@ export interface SessionDataShape {
   messages?: any[];
 }
 
+/** Session identity a spawn established before omp's JSONL is readable. */
+export interface SessionSeed {
+  model?: { provider: string; modelId: string } | null;
+  thinkingLevel?: string | null;
+}
+
 export interface UseSessionLoadDeps {
   sessionId: string | null;
   setLocalMessages: Dispatch<SetStateAction<ChatMessageData[]>>;
@@ -59,24 +66,7 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
   const { sessionId, setLocalMessages, setGenerating, isGeneratingRef, aiPlaceholderIdRef, localMessagesRef, optimisticUserIdRef, cancelStreamingCoalescer, metaRefreshedRef, scrollRef } = deps;
 
   const [sessionData, setSessionData] = useState<SessionDataShape | null>(null);
-  // History pagination state: the first fetch receives the newest window only;
-  // scrolling to the top pages further back via ?before=oldestIndex.
-  const [hasMore, setHasMore] = useState(false);
-  const [oldestIndex, setOldestIndex] = useState(0);
-  const [loadingOlder, setLoadingOlder] = useState(false);
-  // Sticky failure flag for the "Load earlier messages" affordance: a failed
-  // page fetch must keep the button visible (retryable) instead of silently
-  // dropping hasMore, which made the button vanish with no feedback.
-  const [loadOlderError, setLoadOlderError] = useState(false);
-  // Bumped on every successful older-window prepend; the scroll-anchor layout
-  // effect keys on it (its other deps have stable identities, so it needs an
-  // explicit change signal per commit).
-  const [prependTick, setPrependTick] = useState(0);
-  const loadingOlderRef = useRef(false);
   const [sessionLoading, setSessionLoading] = useState(false);
-  // Set while prepending older rows; the layout effect below re-anchors the
-  // viewport to the content the user was reading instead of jumping.
-  const pendingScrollAnchorRef = useRef<{ prevHeight: number; prevTop: number } | null>(null);
   const prevSessionIdRef = useRef<string | null>(null);
   // Real session id adopted by a fresh spawn ("new-…" → UUID). onAgentStart
   // may fire before React re-renders with the new URL, so it reads the id
@@ -84,16 +74,33 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
   const adoptedSessionIdRef = useRef<string | null>(null);
   // Model seeded from the spawn response; kept until the JSONL writes model_change.
   const seededModelRef = useRef<{ provider: string; modelId: string } | null>(null);
+  // Thinking level seeded from the spawn response. The spawn's
+  // `set_thinking_level` IS the level this session runs, and `/api/chat/:id`
+  // cannot report it until omp's JSONL is locatable — until then the loader
+  // answers from the chamber DB copy, which carries no thinkingLevel at all.
+  // Without this seed the composer that takes over the pending view falls back
+  // to a catalog default and claims a level the run never used.
+  const seededThinkingLevelRef = useRef<string | null>(null);
 
   const applySessionData = useCallback((incoming: SessionDataShape) => {
     if (incoming.model && typeof incoming.model === 'object') seededModelRef.current = incoming.model;
     const model = incoming.model ?? (isGeneratingRef.current ? seededModelRef.current ?? undefined : undefined);
-    setSessionData({ ...incoming, model });
+    const thinkingLevel = incoming.thinkingLevel ?? seededThinkingLevelRef.current ?? undefined;
+    setSessionData({ ...incoming, model, thinkingLevel });
   }, []);
 
   const sessionIdRef = useRef(sessionId);
   sessionIdRef.current = sessionId;
 
+  // Older-window pagination (cursor, retry flag, scroll anchoring) lives in its
+  // own hook so this one stays under the repo's per-file size ceiling.
+  const { hasMore, loadingOlder, loadOlderError, loadOlder, resetPages, applyWindow } = useSessionPagination({
+    sessionId,
+    sessionIdRef,
+    setLocalMessages,
+    scrollRef,
+  });
+
   /** Re-fetch the session's title/metadata after the omp JSONL has been
    *  written (spawn or agent end) so the navbar and context panel show the
    *  real session title instead of the default. Retries on a front-loaded
@@ -127,9 +134,17 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
     tryFetch();
   }, [applySessionData]);
 
-  const setSessionModelWithSeed = useCallback((model: { provider: string; modelId: string } | null) => {
-    seededModelRef.current = model;
-    setSessionData(prev => ({ ...(prev ?? {}), model: model ?? undefined }));
+  /** Adopt a spawn's session identity: the model and the thinking level the
+   *  first prompt is running with. Only the fields a caller supplies are
+   *  written, so a null model/level leaves the previous value untouched. */
+  const seedSession = useCallback((seed: SessionSeed) => {
+    if (seed.model) seededModelRef.current = seed.model;
+    if (seed.thinkingLevel) seededThinkingLevelRef.current = seed.thinkingLevel;
+    setSessionData(prev => ({
+      ...(prev ?? {}),
+      ...(seed.model ? { model: seed.model } : {}),
+      ...(seed.thinkingLevel ? { thinkingLevel: seed.thinkingLevel } : {}),
+    }));
   }, []);
 
   /** Whether the optimistic bubble set currently owns the timeline tail (a
@@ -159,6 +174,14 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
         setGenerating(false);
         adoptedSessionIdRef.current = null;
         seededModelRef.current = null;
+        // Metadata (model / thinking level) belongs to ONE session: leaving it
+        // in place let a pending "new-…" composer — and any other session's
+        // composer — display a level that session never ran with, until the
+        // fetch replaced it.
+        setSessionData(null);
+        // The thinking seed belongs to the previous session's spawn; keeping it
+        // would report that level for the newly opened session.
+        seededThinkingLevelRef.current = null;
         // The placeholder/optimistic ids belong to the PREVIOUS session's
         // in-flight send; message_end never arrives after a switch away (the
         // stream is disconnected), so they must be dropped here. A stale
@@ -174,11 +197,7 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
       }
       // Reset pagination cursor on every session switch — the window belongs
       // to the previous session otherwise.
-      setHasMore(false);
-      setOldestIndex(0);
-      loadingOlderRef.current = false;
-      setLoadingOlder(false);
-      setLoadOlderError(false);
+      resetPages();
       // metaRefreshedRef must NOT survive a session switch — including a
       // spawn adoption. It is the once-per-session guard in onAgentStart
       // (omp-callbacks.ts); keeping the stale value here ate the retrigger,
@@ -216,8 +235,7 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
             } else if (!sessionId.startsWith('new-') && !optimisticOwnsTail) {
               setLocalMessages([]);
             }
-            if (typeof data.hasMore === 'boolean') setHasMore(data.hasMore);
-            if (typeof data.oldestIndex === 'number') setOldestIndex(data.oldestIndex);
+            applyWindow(data.hasMore, data.oldestIndex);
           } else {
             setSessionData(null);
             if (!timelineOwnedByOptimistic()) setLocalMessages([]);
@@ -243,79 +261,6 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [sessionId, applySessionData, timelineOwnedByOptimistic, setLocalMessages, setGenerating]);
 
-  /** Page the next older window into the timeline. Called from the click
-   *  handler and the scroll handler when the viewport reaches the top; a no-op
-   *  while a page is in flight, when the session has no more history, or while
-   *  the session is a pending optimistic spawn. Prepending older rows only
-   *  grows the list ABOVE the tail, so it is safe while the agent is
-   *  generating — unlike a committed refetch, it never clobbers the AI
-   *  placeholder, and blocking it made the button feel dead mid-run. */
-  const loadOlder = useCallback(() => {
-    if (!sessionId || sessionId.startsWith('new-')) return;
-    if (!hasMore || loadingOlderRef.current) return;
-    loadingOlderRef.current = true;
-    setLoadingOlder(true);
-    setLoadOlderError(false);
-    const el = scrollRef?.current;
-    if (el) pendingScrollAnchorRef.current = { prevHeight: el.scrollHeight, prevTop: el.scrollTop };
-    // Session id snapshot: prepending a window fetched for the PREVIOUS
-    // session into the freshly-switched timeline is worse than dropping the
-    // page, so the response is discarded if the user switched mid-flight.
-    const requestedSessionId = sessionId;
-    fetch(`/api/chat/${sessionId}?before=${oldestIndex}`)
-      .then(res => {
-        if (!res.ok) throw new Error(`HTTP ${res.status}`);
-        return res.json();
-      })
-      .then((data: { session?: { messages?: ChatMessageData[] }; hasMore?: boolean; oldestIndex?: number }) => {
-        // The main load effect may have cleared/repurposed localMessages for a
-        // new session while this fetch was in flight.
-        if (sessionIdRef.current !== requestedSessionId) return;
-        const older = data.session?.messages ?? [];
-        setHasMore(Boolean(data.hasMore));
-        if (typeof data.oldestIndex === 'number') setOldestIndex(data.oldestIndex);
-        if (older.length === 0) {
-          // No rows prepended: the recorded anchor is stale — drop it so a
-          // later tick cannot apply it against the wrong geometry.
-          pendingScrollAnchorRef.current = null;
-          return;
-        }
-        setLocalMessages(prev => {
-          // Drop overlap guard: the server window is index-based, so the
-          // fetched slice is strictly older than everything already mounted.
-          return [...older, ...prev];
-        });
-        // Bump the prepend tick so the layout effect below re-runs for THIS
-        // commit — it previously depended only on stable identities and ran
-        // exactly once at mount, so the viewport anchor never fired and every
-        // pagination jump snapped the user to the (shifted) top.
-        setPrependTick(t => t + 1);
-      })
-      .catch(() => {
-        // Keep the button mounted and marked for retry; a swallowed failure
-        // previously also cleared hasMore on the next full reload path.
-        if (sessionIdRef.current === requestedSessionId) setLoadOlderError(true);
-      })
-      .finally(() => {
-        loadingOlderRef.current = false;
-        setLoadingOlder(false);
-      });
-  }, [sessionId, hasMore, oldestIndex, scrollRef, setLocalMessages]);
-
-  // Position preservation: after older rows commit above the viewport, shift
-  // scrollTop by the height delta so the rows the user was reading stay put.
-  // prependTick changes on every prepend — without it the effect ran only at
-  // mount (its other deps are stable) and never re-anchored.
-  useLayoutEffect(() => {
-    const anchor = pendingScrollAnchorRef.current;
-    if (!anchor) return;
-    const el = scrollRef?.current;
-    if (!el) return;
-    pendingScrollAnchorRef.current = null;
-    const delta = el.scrollHeight - anchor.prevHeight;
-    if (delta > 0) el.scrollTop = anchor.prevTop + delta;
-  }, [prependTick, scrollRef]);
-
   return {
     sessionData,
     hasMore,
@@ -324,10 +269,7 @@ export function useSessionLoad(deps: UseSessionLoadDeps) {
     sessionLoading,
     loadOlder,
     adoptedSessionIdRef,
-    seededModelRef,
-    applySessionData,
     refreshSessionMeta,
-    setSessionModel: setSessionModelWithSeed,
-    timelineOwnedByOptimistic,
+    seedSession,
   };
 }