@tea-agent/loop-agent 0.42.0-next.1 → 0.42.0-next.10

package/dist/worker/console/static-src/operator-chat/useChatSessions.js

@@ -3,9 +3,98 @@ import { runtimeSelectionFromRecord } from "../../chat/runtime-selection.js";
 import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { forgetActiveChatSession, readActiveChatSessionId, rememberActiveChatSession, } from "../../chat/workspace-landing.js";
 import { confirmationToken } from "./format.js";
+import { isLostChatSessionError } from "./runtime-snapshot-store.js";
 import { upsertCompactionMessage } from "./compaction-message.js";
 import { describeMutationGateFailure, isMutationGateFailureCode, isStaleTokenFailure, } from "./mutation-gate.js";
 import { SessionTitleWatcher } from "./session-title-watcher.js";
+/** Pure list mutations keep optimistic UI deterministic and easy to verify. */
+export function insertOptimisticSession(list, row) {
+    return [row, ...list.filter((item) => item.sessionId !== row.sessionId)];
+}
+export function replaceOptimisticSession(list, temporaryId, durable) {
+    return [
+        durable,
+        ...list.filter((item) => item.sessionId !== durable.sessionId &&
+            (!temporaryId || item.sessionId !== temporaryId)),
+    ];
+}
+export function removeSessionById(list, sessionId) {
+    const index = list.findIndex((item) => item.sessionId === sessionId);
+    if (index < 0)
+        return { next: list, index: -1 };
+    return {
+        next: list.filter((item) => item.sessionId !== sessionId),
+        removed: list[index],
+        index,
+    };
+}
+export function restoreSessionAt(list, row, index) {
+    if (list.some((item) => item.sessionId === row.sessionId))
+        return list;
+    const next = [...list];
+    next.splice(Math.max(0, Math.min(index, next.length)), 0, row);
+    return next;
+}
+function sameQueueSummary(a, b) {
+    const left = a.deferredTurns ?? (a.deferredTurn ? [a.deferredTurn] : []);
+    const right = b.deferredTurns ?? (b.deferredTurn ? [b.deferredTurn] : []);
+    if (left.length !== right.length)
+        return false;
+    return left.every((item, index) => {
+        const other = right[index];
+        return Boolean(other &&
+            item.clientRequestId === other.clientRequestId &&
+            item.revision === other.revision &&
+            item.state === other.state &&
+            item.updatedAt === other.updatedAt &&
+            item.textPreview === other.textPreview &&
+            item.imageCount === other.imageCount &&
+            item.acceptedTurnId === other.acceptedTurnId &&
+            item.lastError?.code === other.lastError?.code &&
+            item.lastError?.message === other.lastError?.message);
+    });
+}
+function sameSessionSummary(a, b) {
+    return (a.sessionId === b.sessionId &&
+        a.workspaceId === b.workspaceId &&
+        a.state === b.state &&
+        a.title === b.title &&
+        a.displayTitle === b.displayTitle &&
+        a.updatedAt === b.updatedAt &&
+        a.activeTurnId === b.activeTurnId &&
+        a.turnPhase === b.turnPhase &&
+        a.model?.provider === b.model?.provider &&
+        a.model?.modelId === b.model?.modelId &&
+        a.thinkingLevel === b.thinkingLevel &&
+        a.isBlank === b.isBlank &&
+        a.optimisticState === b.optimisticState &&
+        sameQueueSummary(a, b));
+}
+/** Reuse unchanged row and list references across catalog refreshes. */
+export function stabilizeSessionList(previous, next) {
+    const previousById = new Map(previous.map((item) => [item.sessionId, item]));
+    let changed = previous.length !== next.length;
+    const stabilized = next.map((item, index) => {
+        const existing = previousById.get(item.sessionId);
+        const value = existing && sameSessionSummary(existing, item) ? existing : item;
+        if (value !== previous[index])
+            changed = true;
+        return value;
+    });
+    return changed ? stabilized : previous;
+}
+/** Select a server-confirmed blank session owned by the requested workspace. */
+export function findReusableBlankSession(list, workspaceId) {
+    const scope = workspaceId.trim();
+    if (!scope)
+        return undefined;
+    return list.find((item) => item.workspaceId === scope &&
+        item.state === "active" &&
+        item.isBlank === true &&
+        item.turnPhase === "idle" &&
+        !item.activeTurnId &&
+        !item.optimisticState);
+}
 export async function createSessionAndPrimeTitleWatcher(input) {
     if (input.creatingRef?.current) {
         throw new Error("CREATE_SESSION_IN_FLIGHT");
@@ -23,7 +112,10 @@ export async function createSessionAndPrimeTitleWatcher(input) {
                 "x-loop-console-confirmation": confirmationToken(),
             },
             credentials: "include",
-            body: JSON.stringify(input.options ?? {}),
+            body: JSON.stringify((() => {
+                const { optimisticSessionId: _optimisticSessionId, ...body } = input.options ?? {};
+                return body;
+            })()),
         });
         if (!res.ok) {
             const body = (await res.json().catch(() => ({})));
@@ -35,7 +127,7 @@ export async function createSessionAndPrimeTitleWatcher(input) {
         const body = (await res.json());
         if (!body.session)
             throw new Error("创建会话响应缺少 durable session");
-        const durable = body.session;
+        const durable = { ...body.session, isBlank: true };
         const created = {
             sessionId: durable.sessionId,
             ...(durable.workspaceId || input.options?.workspaceId
@@ -45,16 +137,12 @@ export async function createSessionAndPrimeTitleWatcher(input) {
                 : {}),
             ...runtimeSelectionFromRecord(durable),
         };
-        const nextList = [
-            durable,
-            ...input.sessionListRef.current.filter((item) => item.sessionId !== durable.sessionId),
-        ];
+        const nextList = replaceOptimisticSession(input.sessionListRef.current, input.options?.optimisticSessionId, durable);
         // Commit ref → state → eligibility → deferred refresh. The ref assignment
         // makes the durable record observable before React's state commit.
         input.sessionListRef.current = nextList;
         input.setSessionList(nextList);
         input.titleWatcher?.markEligible(durable.sessionId);
-        void input.refreshSessionList();
         return created;
     }
     finally {
@@ -70,7 +158,7 @@ function mergeCompactionMessages(messages, compactions) {
  *  compact, plus browser-refresh recovery from the durable session store. */
 export function useChatSessions(params) {
     const { origin, refs, setSession, thread, composer, browser, setError, setNotice, onCompactionChange, setProcessOpen, setAutoScroll, } = params;
-    const { applyActivatedSession, resetForNewSession, setMessages } = thread;
+    const { applyActivatedSession, resetForNewSession } = thread;
     const { setInput, setPendingImages } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
     const { workspaceId, blocked } = params;
@@ -90,6 +178,11 @@ export function useChatSessions(params) {
     }, [refs]);
     const [sessionList, setSessionList] = useState([]);
     const sessionListRef = useRef([]);
+    const pendingDeletedIdsRef = useRef(new Set());
+    const pendingCreatedRowsRef = useRef(new Map());
+    const sessionMutationVersionRef = useRef(0);
+    const deleteRequestVersionsRef = useRef(new Map());
+    const activateSessionRef = useRef(null);
     sessionListRef.current = sessionList;
     const titleWatcherRef = useRef(null);
     // Shared busy gate for sidebar + Landing create entries (one render feedback).
@@ -159,9 +252,13 @@ export function useChatSessions(params) {
                 return;
             }
             const sessions = body.sessions ?? [];
+            const durable = sessions.filter((item) => !pendingDeletedIdsRef.current.has(item.sessionId));
+            const optimistic = [...pendingCreatedRowsRef.current.values()].filter((item) => !durable.some((session) => session.sessionId === item.sessionId));
             // Preserve every workspace's summaries. ChatWorkspaceSidebar applies the
             // visible recent-item limit independently inside each workspace group.
-            setSessionList(sessions);
+            const next = stabilizeSessionList(sessionListRef.current, [...optimistic, ...durable]);
+            sessionListRef.current = next;
+            setSessionList(next);
             if (body.workspaceErrors?.length) {
                 setError(`部分工作区的会话加载失败（${body.workspaceErrors.length} 个）`);
             }
@@ -171,6 +268,60 @@ export function useChatSessions(params) {
         }
     }, [origin, blocked, setError]);
     const deleteSession = useCallback(async (sessionId) => {
+        if (pendingDeletedIdsRef.current.has(sessionId))
+            return false;
+        const requestId = ++sessionMutationVersionRef.current;
+        const currentList = sessionListRef.current;
+        const { next: removedList, removed, index: removedIndex } = removeSessionById(currentList, sessionId);
+        if (!removed || removedIndex < 0)
+            return false;
+        pendingDeletedIdsRef.current.add(sessionId);
+        deleteRequestVersionsRef.current.set(sessionId, requestId);
+        const activeSession = refs.sessionRef.current?.sessionId === sessionId
+            ? refs.sessionRef.current
+            : null;
+        const activeWorkspaceId = activeSession?.workspaceId ?? workspaceId;
+        const deletingRow = {
+            ...removed,
+            optimisticState: "deleting",
+        };
+        const deletingList = restoreSessionAt(removedList, deletingRow, removedIndex);
+        sessionListRef.current = deletingList;
+        setSessionList(deletingList);
+        window.setTimeout(() => {
+            if (!pendingDeletedIdsRef.current.has(sessionId) ||
+                deleteRequestVersionsRef.current.get(sessionId) !== requestId)
+                return;
+            const next = sessionListRef.current.filter((item) => item.sessionId !== sessionId);
+            sessionListRef.current = next;
+            setSessionList(next);
+        }, 150);
+        const restore = () => {
+            if (deleteRequestVersionsRef.current.get(sessionId) !== requestId)
+                return;
+            pendingDeletedIdsRef.current.delete(sessionId);
+            deleteRequestVersionsRef.current.delete(sessionId);
+            const restored = restoreSessionAt(sessionListRef.current, removed, removedIndex);
+            if (restored === sessionListRef.current)
+                return;
+            sessionListRef.current = restored;
+            setSessionList(restored);
+        };
+        let deletionSelectionVersion = null;
+        if (activeSession) {
+            deletionSelectionVersion = ++sessionSelectionVersionRef.current;
+            refs.sessionRef.current = null;
+            resetActiveProjection();
+            setSession(null);
+            forgetActiveChatSession(window.localStorage, activeWorkspaceId, sessionId);
+        }
+        const restoreActiveSession = async () => {
+            if (activeSession &&
+                deletionSelectionVersion === sessionSelectionVersionRef.current &&
+                !refs.sessionRef.current) {
+                await activateSessionRef.current?.(activeSession.sessionId, activeSession.workspaceId);
+            }
+        };
         try {
             // AC-002: delete follows the session's durable owner, not the
             // global active workspace.
@@ -184,22 +335,21 @@ export function useChatSessions(params) {
                 },
             });
             if (!res.ok) {
+                restore();
+                await restoreActiveSession();
                 setError("删除会话失败");
                 return false;
             }
             titleWatcherRef.current?.cancel(sessionId);
-            if (refs.sessionRef.current?.sessionId === sessionId) {
-                const activeWorkspaceId = refs.sessionRef.current.workspaceId ?? workspaceId;
-                sessionSelectionVersionRef.current += 1;
-                refs.sessionRef.current = null;
-                resetActiveProjection();
-                setSession(null);
-                forgetActiveChatSession(window.localStorage, activeWorkspaceId, sessionId);
-            }
-            await refreshSessionList();
+            void refreshSessionList().finally(() => {
+                pendingDeletedIdsRef.current.delete(sessionId);
+                deleteRequestVersionsRef.current.delete(sessionId);
+            });
             return true;
         }
         catch (error) {
+            restore();
+            await restoreActiveSession();
             setError(error instanceof Error ? error.message : String(error));
             return false;
         }
@@ -213,6 +363,23 @@ export function useChatSessions(params) {
         sessionOwnerQuery,
         workspaceId,
     ]);
+    const forgetLostSession = useCallback((sessionId, ownerWorkspaceId) => {
+        const active = refs.sessionRef.current;
+        const listed = sessionListRef.current.find((item) => item.sessionId === sessionId);
+        const scope = ownerWorkspaceId ?? listed?.workspaceId ?? active?.workspaceId ?? workspaceId;
+        forgetActiveChatSession(window.localStorage, scope, sessionId);
+        pendingDeletedIdsRef.current.add(sessionId);
+        const { next } = removeSessionById(sessionListRef.current, sessionId);
+        sessionListRef.current = next;
+        setSessionList(next);
+        if (active?.sessionId === sessionId) {
+            sessionSelectionVersionRef.current += 1;
+            refs.sessionRef.current = null;
+            resetActiveProjection();
+            setSession(null);
+        }
+        void refreshSessionList();
+    }, [refs, resetActiveProjection, setSession, workspaceId, refreshSessionList]);
     const activateSession = useCallback(async (sessionId, ownerWorkspaceId) => {
         const selectionVersion = ++sessionSelectionVersionRef.current;
         // AC-002: activation targets the session's durable owning workspace —
@@ -222,10 +389,19 @@ export function useChatSessions(params) {
         try {
             const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}${ownerQuery}`, { credentials: "include" });
             const body = (await res.json());
-            if (!res.ok || !body.session)
+            if (!res.ok || !body.session) {
+                if (isLostChatSessionError({
+                    status: res.status,
+                    code: body.error?.code,
+                    message: body.error?.message,
+                })) {
+                    forgetLostSession(sessionId, ownerWorkspaceId);
+                    return false;
+                }
                 throw new Error(body.error?.message ?? "会话不可用");
+            }
             if (selectionVersion !== sessionSelectionVersionRef.current)
-                return;
+                return false;
             const next = {
                 sessionId: body.session.sessionId,
                 ...(body.session.workspaceId ? { workspaceId: body.session.workspaceId } : {}),
@@ -273,14 +449,17 @@ export function useChatSessions(params) {
                 pendingQuestion: body.session.pendingQuestion ?? null,
                 todos: body.session.todos ?? [],
                 goal: body.session.goal ?? null,
+                history: body.history,
             });
             rememberActiveChatSession(window.localStorage, body.session.workspaceId ?? ownerWorkspaceId ?? workspaceId, sessionId);
             setActivePreviewPath(null);
+            return true;
         }
         catch (error) {
             if (selectionVersion !== sessionSelectionVersionRef.current)
-                return;
+                return false;
             setError(error instanceof Error ? error.message : String(error));
+            return false;
         }
     }, [
         origin,
@@ -295,7 +474,9 @@ export function useChatSessions(params) {
         setError,
         sessionOwnerQuery,
         workspaceId,
+        forgetLostSession,
     ]);
+    activateSessionRef.current = activateSession;
     useEffect(() => {
         void refreshSessionList();
     }, [refreshSessionList]);
@@ -405,6 +586,7 @@ export function useChatSessions(params) {
                     pendingQuestion: body.session.pendingQuestion ?? null,
                     todos: body.session.todos ?? [],
                     goal: body.session.goal ?? null,
+                    history: body.history,
                 });
             }
             catch {
@@ -437,15 +619,38 @@ export function useChatSessions(params) {
             setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
             return Promise.reject(new Error("WORKSPACE_REQUIRED"));
         }
+        const optimisticSessionId = `optimistic-chat-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+        const now = new Date().toISOString();
+        const optimisticRow = {
+            sessionId: optimisticSessionId,
+            workspaceId: scope,
+            state: "active",
+            updatedAt: now,
+            turnPhase: "idle",
+            optimisticState: "creating",
+        };
+        pendingCreatedRowsRef.current.set(optimisticSessionId, optimisticRow);
+        const optimisticList = insertOptimisticSession(sessionListRef.current, optimisticRow);
+        sessionListRef.current = optimisticList;
+        setSessionList(optimisticList);
         return createSessionAndPrimeTitleWatcher({
             origin,
             sessionListRef,
             setSessionList,
             titleWatcher: titleWatcherRef.current,
             refreshSessionList,
-            options: { ...options, workspaceId: scope },
+            options: { ...options, workspaceId: scope, optimisticSessionId },
             setCreatingSession,
             creatingRef: creatingSessionRef,
+        }).then((created) => {
+            pendingCreatedRowsRef.current.delete(optimisticSessionId);
+            return created;
+        }).catch((error) => {
+            pendingCreatedRowsRef.current.delete(optimisticSessionId);
+            const cleaned = sessionListRef.current.filter((item) => item.sessionId !== optimisticSessionId);
+            sessionListRef.current = cleaned;
+            setSessionList(cleaned);
+            throw error;
         });
     }, [origin, refreshSessionList, workspaceId, setError]);
     const createSession = useCallback(async (options) => {
@@ -456,11 +661,36 @@ export function useChatSessions(params) {
             return null; // AC-R5-002: unknown workspace — no POST
         const selectionVersion = ++sessionSelectionVersionRef.current;
         setError(null);
+        const previousSession = refs.sessionRef.current;
+        const scope = options?.workspaceId?.trim() ?? workspaceId?.trim();
+        if (!scope) {
+            setError("创建会话需要选择一个有效的工作区（不会回退默认工作区）");
+            return null;
+        }
+        // A caller-provided snapshot is an explicit new-session boundary; reusing
+        // an existing shell would silently drop that context suffix.
+        const reusable = options?.snapshot
+            ? undefined
+            : findReusableBlankSession(sessionListRef.current, scope);
+        if (reusable) {
+            if (previousSession?.sessionId === reusable.sessionId)
+                return previousSession;
+            const activated = await activateSession(reusable.sessionId, reusable.workspaceId);
+            if (!activated)
+                return null;
+            return {
+                sessionId: reusable.sessionId,
+                ...(reusable.workspaceId ? { workspaceId: reusable.workspaceId } : {}),
+                ...runtimeSelectionFromRecord(reusable),
+            };
+        }
         try {
+            resetActiveProjection({ keepStreams: true });
+            refs.sessionRef.current = null;
+            setSession(null);
             const created = await createSessionAndPrimeTitleWatcherForHook(options);
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
-            resetActiveProjection({ keepStreams: true });
             // Set ref synchronously BEFORE setState so a chained
             // createSession().then(sendPrompt) reads the new session even
             // though sendPrompt's closure captured the stale (null) value.
@@ -472,6 +702,9 @@ export function useChatSessions(params) {
         catch (e) {
             if (selectionVersion !== sessionSelectionVersionRef.current)
                 return null;
+            if (previousSession) {
+                await activateSession(previousSession.sessionId, previousSession.workspaceId);
+            }
             const message = e instanceof Error ? e.message : String(e);
             if (message !== "CREATE_SESSION_IN_FLIGHT") {
                 setError(message);
@@ -484,6 +717,7 @@ export function useChatSessions(params) {
         setError,
         resetActiveProjection,
         createSessionAndPrimeTitleWatcherForHook,
+        activateSession,
         blocked,
         workspaceId,
     ]);
@@ -595,5 +829,6 @@ export function useChatSessions(params) {
         updateSession,
         watchSessionTitle,
         compactSession,
+        forgetLostSession,
     };
 }

package/dist/worker/console/static-src/operator-chat/useChatThread.js

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { buildTurnProcessGroups, hydrateSessionThread, selectRecentTurnGroups, } from "../../chat/turn-process.js";
 import { mergeOperationCardState, } from "../../chat/operation-card.js";
 import { createChatSseEventApplier, } from "./chat-sse-events.js";
@@ -118,6 +118,10 @@ export function useChatThread(params) {
     const [operationCards, setOperationCards] = useState([]);
     const [artifactCards, setArtifactCards] = useState([]);
     const [historyLimit, setHistoryLimit] = useState(50);
+    const [historyHasMore, setHistoryHasMore] = useState(false);
+    const [historyNextCursor, setHistoryNextCursor] = useState(null);
+    const [historyLoading, setHistoryLoading] = useState(false);
+    const historyLoadingRef = useRef(false);
     const [unread, setUnread] = useState(0);
     const [humanGateCards, setHumanGateCards] = useState([]);
     const [interview, setInterview] = useState(null);
@@ -136,6 +140,8 @@ export function useChatThread(params) {
     /** Assistant bubble id for the in-flight turn; only this row shows the streaming cursor. */
     const [streamingAssistantId, setStreamingAssistantId] = useState(null);
     const [showSystemInMessages] = useState(false);
+    const completedGroupsRef = useRef([]);
+    const previousTimelineRef = useRef(null);
     const refreshSessionTelemetry = useCallback(async () => {
         const targetSessionId = refs.sessionRef.current?.sessionId;
         if (!targetSessionId)
@@ -301,12 +307,55 @@ export function useChatThread(params) {
         };
     }, [toolCalls]);
     const turnGroups = useMemo(() => {
-        const all = buildTurnProcessGroups({
+        const previousTimeline = previousTimelineRef.current;
+        let built;
+        const activeIndex = streamingAssistantId
+            ? timelineMessages.findIndex((message) => message.id === streamingAssistantId)
+            : -1;
+        const canBuildActiveTail = Boolean(previousTimeline && streaming && streamingAssistantId && activeIndex >= 0) &&
+            previousTimeline?.activeAssistantId === streamingAssistantId &&
+            (previousTimeline?.messages.every((message, index) => message.id === streamingAssistantId || timelineMessages[index]?.id === message.id) ?? false);
+        if (canBuildActiveTail && previousTimeline) {
+            let tailStart = activeIndex;
+            while (tailStart > 0 && timelineMessages[tailStart - 1]?.role !== "user")
+                tailStart -= 1;
+            const tailMessages = timelineMessages.slice(tailStart);
+            const tailIds = new Set(tailMessages.map((message) => message.id));
+            const tailTurnIds = new Set(tailMessages.map((message) => message.turnId).filter(Boolean));
+            const tailTools = toolCalls.filter((tool) => tailIds.has(tool.assistantMessageId ?? "") ||
+                (Boolean(tool.turnId) && tailTurnIds.has(tool.turnId)) ||
+                (tool.createdAt >= (tailMessages[0]?.createdAt ?? Number.POSITIVE_INFINITY)));
+            const activeTail = buildTurnProcessGroups({
+                messages: tailMessages,
+                toolCalls: tailTools,
+                streaming,
+                activeAssistantId: streamingAssistantId,
+            });
+            built = [...previousTimeline.groups.filter((group) => !group.live), ...activeTail];
+        }
+        else {
+            built = buildTurnProcessGroups({
+                messages: timelineMessages,
+                toolCalls,
+                streaming,
+                activeAssistantId: streamingAssistantId,
+            });
+        }
+        // Preserve completed group objects across streaming tokens. The active
+        // tail is rebuilt, while stable historical groups keep their references so
+        // memoized rows do not re-render or re-parse the full conversation.
+        const previous = new Map(completedGroupsRef.current.map((group) => [group.key, group]));
+        const all = built.map((group) => {
+            const cached = previous.get(group.key);
+            return cached && !group.live ? cached : group;
+        });
+        completedGroupsRef.current = all.filter((group) => !group.live);
+        previousTimelineRef.current = {
             messages: timelineMessages,
             toolCalls,
-            streaming,
             activeAssistantId: streamingAssistantId,
-        });
+            groups: all,
+        };
         return selectRecentTurnGroups(all, historyLimit);
     }, [
         timelineMessages,
@@ -315,6 +364,50 @@ export function useChatThread(params) {
         streamingAssistantId,
         historyLimit,
     ]);
+    const loadEarlierMessages = useCallback(async () => {
+        const targetSessionId = refs.sessionRef.current?.sessionId;
+        const beforeId = historyNextCursor;
+        if (!targetSessionId || !historyHasMore || !beforeId || historyLoadingRef.current)
+            return false;
+        historyLoadingRef.current = true;
+        setHistoryLoading(true);
+        try {
+            const query = new URLSearchParams({ limit: "50", beforeId });
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(targetSessionId)}/messages?${query.toString()}`, { credentials: "include" });
+            if (!res.ok || refs.sessionRef.current?.sessionId !== targetSessionId)
+                return false;
+            const body = (await res.json());
+            const page = hydrateSessionThread(body.messages ?? []);
+            setMessages((current) => {
+                const seen = new Set();
+                const merged = [...page.messages, ...current].filter((message) => {
+                    if (seen.has(message.id))
+                        return false;
+                    seen.add(message.id);
+                    return true;
+                });
+                return merged.sort((a, b) => {
+                    if (a.eventSeq !== undefined && b.eventSeq !== undefined && a.eventSeq !== b.eventSeq)
+                        return a.eventSeq - b.eventSeq;
+                    return a.createdAt - b.createdAt;
+                });
+            });
+            setToolCalls((current) => {
+                const byId = new Map(current.map((tool) => [tool.id, tool]));
+                for (const tool of page.toolCalls)
+                    byId.set(tool.id, tool);
+                return [...byId.values()].sort((a, b) => a.createdAt - b.createdAt);
+            });
+            setHistoryHasMore(body.hasMore === true);
+            setHistoryNextCursor(body.nextCursor ?? null);
+            setHistoryLimit((value) => value + 50);
+            return true;
+        }
+        finally {
+            historyLoadingRef.current = false;
+            setHistoryLoading(false);
+        }
+    }, [historyHasMore, historyNextCursor, origin, refs]);
     const visibleMessages = useMemo(() => {
         const next = [];
         for (const group of turnGroups) {
@@ -346,6 +439,11 @@ export function useChatThread(params) {
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
+        setHistoryHasMore(false);
+        setHistoryNextCursor(null);
+        historyLoadingRef.current = false;
+        completedGroupsRef.current = [];
+        previousTimelineRef.current = null;
         refs.usageResponseKeysRef.current = new Set();
     }, [refs]);
     /** Adopt a freshly activated session's hydrated thread + streaming flags. */
@@ -374,6 +472,10 @@ export function useChatThread(params) {
         setStreamingAssistantId(null);
         setUnread(0);
         setHistoryLimit(50);
+        setHistoryHasMore(next.history?.hasMore === true);
+        setHistoryNextCursor(next.history?.nextCursor ?? null);
+        completedGroupsRef.current = [];
+        previousTimelineRef.current = null;
     }, [refs]);
     /** Reconcile recovery (AC-001/AC-002/AC-003): reload the canonical session
      *  facts (session-store messages + event-ring tail cursor) and REPLACE the
@@ -417,6 +519,8 @@ export function useChatThread(params) {
             const hydrated = hydrateSessionThread(body.session.messages ?? []);
             setMessages(mergeCompactionMessages(hydrated.messages, body.compactions));
             setToolCalls(hydrated.toolCalls);
+            setHistoryHasMore(body.history?.hasMore === true);
+            setHistoryNextCursor(body.history?.nextCursor ?? null);
             setStreamingAssistantId(null);
             return true;
         }
@@ -446,6 +550,10 @@ export function useChatThread(params) {
         artifactCards,
         historyLimit,
         setHistoryLimit,
+        historyHasMore,
+        historyNextCursor,
+        historyLoading,
+        loadEarlierMessages,
         unread,
         humanGateCards,
         interview,