@tea-agent/loop-agent 0.43.0 → 0.44.0-next.10

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

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { runtimeSelectionFromRecord } from "../../chat/runtime-selection.js";
 import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { forgetActiveChatSession, readActiveChatSessionId, rememberActiveChatSession, } from "../../chat/workspace-landing.js";
@@ -8,6 +8,47 @@ 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";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSessionListItem(value) {
+    if (!isRecord(value))
+        return false;
+    const optionalString = (field) => field === undefined || typeof field === "string";
+    return (typeof value.sessionId === "string" &&
+        value.sessionId.trim().length > 0 &&
+        (value.state === "active" || value.state === "archived") &&
+        typeof value.updatedAt === "string" &&
+        optionalString(value.workspaceId) &&
+        optionalString(value.title) &&
+        optionalString(value.displayTitle) &&
+        optionalString(value.activeTurnId) &&
+        (value.isBlank === undefined || typeof value.isBlank === "boolean") &&
+        (value.sessionMode === undefined ||
+            value.sessionMode === "workflow" ||
+            value.sessionMode === "pi") &&
+        (value.turnPhase === undefined ||
+            value.turnPhase === "idle" ||
+            value.turnPhase === "running" ||
+            value.turnPhase === "stopping"));
+}
+/** A 2xx response is authoritative only after its versioned payload validates. */
+export function parseSessionListBaseline(value) {
+    if (!isRecord(value) || value.schemaVersion !== 2) {
+        throw new Error("会话列表响应版本无效");
+    }
+    if (!Array.isArray(value.sessions) || !value.sessions.every(isSessionListItem)) {
+        throw new Error("会话列表响应缺少有效的 sessions");
+    }
+    const workspaceErrors = value.workspaceErrors ?? [];
+    if (!Array.isArray(workspaceErrors) || !workspaceErrors.every(isRecord)) {
+        throw new Error("会话列表响应包含无效的 workspaceErrors");
+    }
+    return {
+        sessions: value.sessions,
+        workspaceErrors: workspaceErrors,
+    };
+}
 /** 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)];
@@ -179,10 +220,11 @@ 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, setMessages, refreshSessionTelemetry, } = thread;
     const { seedSession, releaseSession } = composer;
     const { setPreviews, setActivePreviewPath } = browser;
     const { workspaceId, blocked } = params;
+    const visibleWorkspaceIds = useMemo(() => new Set(params.visibleWorkspaceIds), [params.visibleWorkspaceIds]);
     const workspaceQuery = workspaceId
         ? `?workspaceId=${encodeURIComponent(workspaceId)}`
         : "";
@@ -198,11 +240,19 @@ export function useChatSessions(params) {
         return owner ? `?workspaceId=${encodeURIComponent(owner)}` : "";
     }, [refs]);
     const [sessionList, setSessionList] = useState([]);
+    const [sessionListStatus, setSessionListStatus] = useState({
+        phase: "pending",
+        state: "idle",
+        error: null,
+    });
     const [selectedSession, setSelectedSession] = useState(null);
     const selectedSessionRef = useRef(null);
     selectedSessionRef.current = selectedSession;
     const sessionListRef = useRef([]);
     const sessionListRequestVersionRef = useRef(0);
+    const sessionListRefreshRef = useRef(null);
+    const sessionListRefreshQueuedRef = useRef(false);
+    const sessionListGlobalErrorRef = useRef(null);
     const pendingDeletedIdsRef = useRef(new Set());
     const pendingCreatedRowsRef = useRef(new Map());
     const sessionMutationVersionRef = useRef(0);
@@ -256,43 +306,101 @@ export function useChatSessions(params) {
         setProcessOpen,
         setAutoScroll,
     ]);
-    const refreshSessionList = useCallback(async () => {
+    const refreshSessionList = useCallback(() => {
         if (blocked)
-            return; // AC-R5-002: fail-closed, zero session requests
-        const version = ++sessionListRequestVersionRef.current;
-        try {
-            // The sidebar is a multi-workspace index. Keep one unscoped summary
-            // collection so expanding or switching a workspace never projects the
-            // previous workspace's list as an empty result while a scoped refresh is
-            // in flight. Session detail and mutation requests remain owner-scoped.
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
-                credentials: "include",
-            });
-            const body = (await res.json().catch(() => ({})));
-            if (version !== sessionListRequestVersionRef.current)
-                return;
-            if (!res.ok) {
-                setError(body.error?.message ?? `会话列表加载失败（HTTP ${res.status}）`);
-                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.
-            const next = stabilizeSessionList(sessionListRef.current, [...optimistic, ...durable]);
-            sessionListRef.current = next;
-            setSessionList(next);
-            if (body.workspaceErrors?.length) {
-                setError(`部分工作区的会话加载失败（${body.workspaceErrors.length} 个）`);
-            }
+            return Promise.resolve(); // AC-R5-002: fail-closed, zero requests
+        if (sessionListRefreshRef.current) {
+            // The newest refresh may carry a different visible-workspace projection.
+            // Do not briefly commit the older scope before the queued baseline runs.
+            sessionListRequestVersionRef.current += 1;
+            sessionListRefreshQueuedRef.current = true;
+            return sessionListRefreshRef.current;
         }
-        catch (error) {
-            if (version !== sessionListRequestVersionRef.current)
-                return;
-            setError(`会话列表加载失败：${error instanceof Error ? error.message : String(error)}`);
+        const request = (async () => {
+            do {
+                sessionListRefreshQueuedRef.current = false;
+                const version = ++sessionListRequestVersionRef.current;
+                setSessionListStatus((current) => ({
+                    ...current,
+                    state: "loading",
+                    error: null,
+                }));
+                try {
+                    // The sidebar is one unscoped multi-workspace index. Session detail
+                    // and mutations remain owner-scoped.
+                    const res = await fetch(`${origin}/api/operator/v1/chat/sessions`, {
+                        credentials: "include",
+                    });
+                    let rawBody;
+                    try {
+                        rawBody = await res.json();
+                    }
+                    catch {
+                        throw new Error("会话列表响应不是有效 JSON");
+                    }
+                    if (version !== sessionListRequestVersionRef.current) {
+                        sessionListRefreshQueuedRef.current = true;
+                        continue;
+                    }
+                    if (!res.ok) {
+                        const message = isRecord(rawBody) &&
+                            isRecord(rawBody.error) &&
+                            typeof rawBody.error.message === "string"
+                            ? rawBody.error.message
+                            : `会话列表加载失败（HTTP ${res.status}）`;
+                        throw new Error(message);
+                    }
+                    const baseline = parseSessionListBaseline(rawBody);
+                    if (baseline.workspaceErrors.length > 0) {
+                        throw new Error(`部分工作区的会话加载失败（${baseline.workspaceErrors.length} 个）`);
+                    }
+                    const belongsToVisibleWorkspace = (item) => params.workspacesLoading ||
+                        !item.workspaceId ||
+                        visibleWorkspaceIds.has(item.workspaceId);
+                    const durable = baseline.sessions.filter((item) => belongsToVisibleWorkspace(item) &&
+                        !pendingDeletedIdsRef.current.has(item.sessionId));
+                    const optimistic = [...pendingCreatedRowsRef.current.values()].filter((item) => belongsToVisibleWorkspace(item) &&
+                        !durable.some((session) => session.sessionId === item.sessionId));
+                    const next = stabilizeSessionList(sessionListRef.current, [...optimistic, ...durable]);
+                    sessionListRef.current = next;
+                    setSessionList(next);
+                    setSessionListStatus({ phase: "ready", state: "idle", error: null });
+                    const previousListError = sessionListGlobalErrorRef.current;
+                    if (previousListError) {
+                        setError((current) => current === previousListError ? null : current);
+                        sessionListGlobalErrorRef.current = null;
+                    }
+                }
+                catch (error) {
+                    if (version !== sessionListRequestVersionRef.current) {
+                        sessionListRefreshQueuedRef.current = true;
+                        continue;
+                    }
+                    const message = `会话列表加载失败：${error instanceof Error ? error.message : String(error)}`;
+                    setSessionListStatus((current) => ({
+                        ...current,
+                        state: "error",
+                        error: message,
+                    }));
+                    sessionListGlobalErrorRef.current = message;
+                    setError(message);
+                }
+            } while (sessionListRefreshQueuedRef.current && !blocked);
+        })();
+        sessionListRefreshRef.current = request;
+        void request.finally(() => {
+            if (sessionListRefreshRef.current === request) {
+                sessionListRefreshRef.current = null;
+            }
+        });
+        return request;
+    }, [origin, blocked, setError, visibleWorkspaceIds, params.workspacesLoading]);
+    const invalidateSessionListBaseline = useCallback(() => {
+        sessionListRequestVersionRef.current += 1;
+        if (sessionListRefreshRef.current) {
+            sessionListRefreshQueuedRef.current = true;
         }
-    }, [origin, blocked, setError]);
+    }, []);
     const deleteSession = useCallback(async (sessionId) => {
         if (pendingDeletedIdsRef.current.has(sessionId))
             return false;
@@ -302,7 +410,7 @@ export function useChatSessions(params) {
         if (!removed || removedIndex < 0)
             return false;
         // No pre-mutation snapshot may overwrite this deletion or its rollback.
-        sessionListRequestVersionRef.current += 1;
+        invalidateSessionListBaseline();
         pendingDeletedIdsRef.current.add(sessionId);
         deleteRequestVersionsRef.current.set(sessionId, requestId);
         const activeSession = refs.sessionRef.current?.sessionId === sessionId
@@ -335,7 +443,7 @@ export function useChatSessions(params) {
         const restore = () => {
             if (deleteRequestVersionsRef.current.get(sessionId) !== requestId)
                 return;
-            sessionListRequestVersionRef.current += 1;
+            invalidateSessionListBaseline();
             pendingDeletedIdsRef.current.delete(sessionId);
             deleteRequestVersionsRef.current.delete(sessionId);
             const restored = restoreSessionAt(sessionListRef.current.filter((item) => item.sessionId !== sessionId), removed, removedIndex);
@@ -406,6 +514,7 @@ export function useChatSessions(params) {
         setError,
         sessionOwnerQuery,
         workspaceId,
+        invalidateSessionListBaseline,
     ]);
     const forgetLostSession = useCallback((sessionId, ownerWorkspaceId) => {
         const active = refs.sessionRef.current;
@@ -418,6 +527,7 @@ export function useChatSessions(params) {
         forgetActiveChatSession(window.localStorage, scope, sessionId);
         releaseSession(identity);
         pendingDeletedIdsRef.current.add(sessionId);
+        invalidateSessionListBaseline();
         const { next } = removeSessionById(sessionListRef.current, sessionId);
         sessionListRef.current = next;
         setSessionList(next);
@@ -430,7 +540,15 @@ export function useChatSessions(params) {
             setSession(null);
         }
         void refreshSessionList();
-    }, [refs, releaseSession, resetActiveProjection, setSession, workspaceId, refreshSessionList]);
+    }, [
+        refs,
+        releaseSession,
+        resetActiveProjection,
+        setSession,
+        workspaceId,
+        refreshSessionList,
+        invalidateSessionListBaseline,
+    ]);
     const activateSession = useCallback(async (sessionId, ownerWorkspaceId) => {
         const selectionVersion = ++sessionSelectionVersionRef.current;
         const listedOwner = sessionListRef.current.find((item) => item.sessionId === sessionId)?.workspaceId;
@@ -497,9 +615,13 @@ export function useChatSessions(params) {
             applyActivatedSession({
                 messages: hydrated.messages,
                 toolCalls: hydrated.toolCalls,
+                turnStates: body.session.turnStates,
+                conversationEvents: body.conversationEvents,
                 sessionStats: body.sessionStats,
                 usage: body.usage,
                 turnTelemetry: body.turnTelemetry,
+                userTurnOutline: body.userTurnOutline,
+                sddSessionIdentity: body.sddDataAlignment ?? null,
                 streaming: visuallyStopped ? false : Boolean(body.session.activeTurnId),
                 turnPhase: body.session.turnPhase ??
                     (body.session.activeTurnId ? "running" : "idle"),
@@ -535,6 +657,32 @@ export function useChatSessions(params) {
         forgetLostSession,
     ]);
     activateSessionRef.current = activateSession;
+    const forkSessionAt = useCallback(async (throughMessageId) => {
+        const current = refs.sessionRef.current;
+        if (!current || refs.activeTurnIdRef.current)
+            return false;
+        try {
+            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(current.sessionId)}/fork${sessionOwnerQuery(current.workspaceId)}`, {
+                method: "POST",
+                credentials: "include",
+                headers: {
+                    "content-type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                body: JSON.stringify({ throughMessageId }),
+            });
+            const body = (await res.json().catch(() => ({})));
+            if (!res.ok || !body.sessionId) {
+                throw new Error(body.error?.message ?? "创建分叉会话失败");
+            }
+            await refreshSessionList();
+            return activateSession(body.sessionId, current.workspaceId);
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+            return false;
+        }
+    }, [activateSession, origin, refreshSessionList, refs, sessionOwnerQuery, setError]);
     useEffect(() => {
         void refreshSessionList();
     }, [refreshSessionList]);
@@ -631,9 +779,13 @@ export function useChatSessions(params) {
                 applyActivatedSession({
                     messages: hydrated.messages,
                     toolCalls: hydrated.toolCalls,
+                    turnStates: body.session.turnStates,
+                    conversationEvents: body.conversationEvents,
                     sessionStats: body.sessionStats,
                     usage: body.usage,
                     turnTelemetry: body.turnTelemetry,
+                    userTurnOutline: body.userTurnOutline,
+                    sddSessionIdentity: body.sddDataAlignment ?? null,
                     streaming: visuallyStopped ? false : Boolean(body.session.activeTurnId),
                     turnPhase: body.session.turnPhase ??
                         (body.session.activeTurnId ? "running" : "idle"),
@@ -688,6 +840,7 @@ export function useChatSessions(params) {
             optimisticState: "creating",
         };
         pendingCreatedRowsRef.current.set(optimisticSessionId, optimisticRow);
+        invalidateSessionListBaseline();
         const optimisticList = insertOptimisticSession(sessionListRef.current, optimisticRow);
         sessionListRef.current = optimisticList;
         setSessionList(optimisticList);
@@ -703,6 +856,14 @@ export function useChatSessions(params) {
                 creatingRef: creatingSessionRef,
             });
             pendingCreatedRowsRef.current.delete(optimisticSessionId);
+            const durableRow = sessionListRef.current.find((item) => item.sessionId === created.sessionId);
+            if (durableRow) {
+                pendingCreatedRowsRef.current.set(created.sessionId, durableRow);
+                invalidateSessionListBaseline();
+                void refreshSessionList().finally(() => {
+                    pendingCreatedRowsRef.current.delete(created.sessionId);
+                });
+            }
             return created;
         }
         catch (error) {
@@ -712,7 +873,13 @@ export function useChatSessions(params) {
             setSessionList(cleaned);
             throw error;
         }
-    }, [origin, refreshSessionList, workspaceId, setError]);
+    }, [
+        origin,
+        refreshSessionList,
+        workspaceId,
+        setError,
+        invalidateSessionListBaseline,
+    ]);
     const createSession = useCallback(async (options) => {
         // Suppress concurrent create from any entry (sidebar / Landing / chip).
         if (creatingSessionRef.current)
@@ -760,6 +927,7 @@ export function useChatSessions(params) {
             setSelectedSession(created);
             rememberActiveChatSession(window.localStorage, created.workspaceId ?? options?.workspaceId ?? workspaceId, created.sessionId);
             setSession(created);
+            void refreshSessionTelemetry();
             return created;
         }
         catch (e) {
@@ -783,6 +951,7 @@ export function useChatSessions(params) {
         activateSession,
         blocked,
         workspaceId,
+        refreshSessionTelemetry,
     ]);
     // Phase-1: fork / in-session branch / mainline switch UI deferred; API routes remain.
     /** Single compact helper for toolbar + `/compact <instructions>` (AC-1). */
@@ -892,11 +1061,13 @@ export function useChatSessions(params) {
     };
     return {
         sessionList,
+        sessionListStatus,
         selectedSession,
         sessionSwitching: Boolean(selectedSession &&
             refs.sessionRef.current?.sessionId !== selectedSession.sessionId),
         creatingSession,
         activateSession,
+        forkSessionAt,
         refreshSessionList,
         deleteSession,
         createSession,

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

@@ -1,9 +1,52 @@
 import { useCallback, useEffect } from "react";
 import { formatOperatorUserError } from "../../operator-user-error.js";
+import { inspectChatSseContinuity, readChatStreamReadyCursor, selectChatSseRepairBlocks, selectLaterChatEventId, } from "./chat-stream-continuity.js";
 import { confirmationToken, requestId, sleep } from "./format.js";
 import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, decideSubmissionRoute, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcileDeferredSubmissionFromState, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
-import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, turnPhaseFromOwnership, visualTurnPhaseFromOwnership, } from "./turn-stream-controller.js";
+import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, createBoundedOwnerSignal, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, turnPhaseFromOwnership, visualTurnPhaseFromOwnership, } from "./turn-stream-controller.js";
 import { appendPendingSubmission, removePendingSubmission } from "./pending-user-message.js";
+import { createTurnStateReconcileQueue, turnStateReconcileTrigger, } from "./turn-state-projection.js";
+const STATE_REQUEST_TIMEOUT_MS = 2_000;
+async function fetchReconciledSessionState(origin, sessionId, options) {
+    const bounded = createBoundedOwnerSignal({
+        ownerSignal: options?.ownerSignal,
+        timeoutMs: STATE_REQUEST_TIMEOUT_MS,
+    });
+    try {
+        const res = await fetch(operatorChatStateUrl(origin, sessionId, options?.turnIds), {
+            credentials: "include",
+            signal: bounded.signal,
+        });
+        const body = (await res.json().catch(() => ({})));
+        if (!res.ok)
+            return null;
+        return body.state ?? null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        bounded.dispose();
+    }
+}
+function readChatSseTurnId(block) {
+    const data = block
+        .split("\n")
+        .filter((line) => line.startsWith("data: "))
+        .map((line) => line.slice(6))
+        .join("");
+    if (!data)
+        return undefined;
+    try {
+        const parsed = JSON.parse(data);
+        return typeof parsed.turnId === "string" && parsed.turnId
+            ? parsed.turnId
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -104,6 +147,18 @@ export function useChatStream(params) {
      * means replay cannot render duplicate messages while live text remains
      * smooth (M4.1/M4.3). */
     const openEventsStream = useCallback(async (sessionId, generation, signal) => {
+        const gapReplayBuffer = [];
+        const turnStateReconciles = createTurnStateReconcileQueue({
+            read: (turnIds) => fetchReconciledSessionState(origin, sessionId, {
+                turnIds,
+                ownerSignal: signal,
+            }),
+            apply: (summaries) => thread.reconcileTurnStates([...summaries]),
+            wait: (delayMs) => sleep(delayMs, signal),
+            isCancelled: () => signal.aborted ||
+                refs.sessionRef.current?.sessionId !== sessionId ||
+                refs.sessionGenerationRef.current !== generation,
+        });
         while (!signal.aborted) {
             const state = refs.eventsStreamStateRef.current;
             if (!state ||
@@ -129,21 +184,48 @@ export function useChatStream(params) {
                 const decoder = new TextDecoder();
                 let buffer = "";
                 let replay = true;
+                let replayRepairNeeded = false;
+                let liveContinuityCursor = null;
                 const fallbackAssistantId = requestId("a");
-                for (;;) {
+                readLoop: for (;;) {
                     const { done, value } = await reader.read();
                     if (done)
                         break;
                     buffer += decoder.decode(value, { stream: true });
                     const blocks = buffer.split("\n\n");
                     buffer = blocks.pop() ?? "";
-                    for (const block of blocks) {
-                        if (sseEventName(block) === "stream_ready") {
+                    for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+                        const block = blocks[blockIndex];
+                        if (block === undefined)
+                            continue;
+                        const eventName = sseEventName(block);
+                        const reconcileTrigger = turnStateReconcileTrigger(replay, eventName);
+                        if (reconcileTrigger) {
+                            const settledTurnId = readChatSseTurnId(block);
+                            if (settledTurnId) {
+                                turnStateReconciles.enqueue(settledTurnId, {
+                                    defer: reconcileTrigger === "after-replay",
+                                });
+                            }
+                        }
+                        if (!replay) {
+                            const continuity = inspectChatSseContinuity(block, liveContinuityCursor);
+                            if (continuity.action === "reconnect") {
+                                // Buffer this block and the rest of the decoded chunk before closing
+                                // the reader. Retained replay repairs structure; the buffer preserves
+                                // cumulative text frames that persistence may have coalesced away.
+                                gapReplayBuffer.push(...blocks.slice(blockIndex));
+                                replayRepairNeeded = true;
+                                break readLoop;
+                            }
+                        }
+                        if (eventName === "stream_ready") {
                             const current = refs.eventsStreamStateRef.current;
                             if (current?.sessionId === sessionId &&
                                 current.generation === generation)
                                 current.ready = true;
                             replay = false;
+                            liveContinuityCursor = readChatStreamReadyCursor(block);
                             // Fall through: the applier owns the buffered-replay flush and
                             // returns immediately for this event. `continue` here silently
                             // dropped that flush, so a reconnect that landed after the
@@ -155,15 +237,41 @@ export function useChatStream(params) {
                             targetSessionId: sessionId,
                             generation,
                         });
-                        if (eventId)
-                            refs.lastEventIdRef.current = eventId;
+                        if (eventId) {
+                            refs.lastEventIdRef.current = selectLaterChatEventId(refs.lastEventIdRef.current, eventId);
+                            if (!replay)
+                                liveContinuityCursor = selectLaterChatEventId(liveContinuityCursor, eventId);
+                        }
+                        if (eventName === "stream_ready" &&
+                            gapReplayBuffer.length > 0) {
+                            const repairedBlocks = selectChatSseRepairBlocks(gapReplayBuffer.splice(0), liveContinuityCursor);
+                            for (const repairedBlock of repairedBlocks) {
+                                const repairedEventId = applySseBlock(repairedBlock, refs.assistantIdRef.current ?? fallbackAssistantId, {
+                                    replay: false,
+                                    targetSessionId: sessionId,
+                                    generation,
+                                });
+                                if (!repairedEventId)
+                                    continue;
+                                refs.lastEventIdRef.current = selectLaterChatEventId(refs.lastEventIdRef.current, repairedEventId);
+                            }
+                        }
+                        if (eventName === "stream_ready") {
+                            void turnStateReconciles.start();
+                        }
                     }
                 }
+                if (replayRepairNeeded) {
+                    await reader.cancel().catch(() => undefined);
+                }
                 const current = refs.eventsStreamStateRef.current;
                 if (current?.sessionId === sessionId &&
                     current.generation === generation)
                     current.ready = false;
-                await sleep(1_000, signal);
+                // A detected hole is expected to be immediately recoverable from the
+                // durable ring. Other EOFs retain the normal reconnect backoff.
+                if (!replayRepairNeeded)
+                    await sleep(1_000, signal);
             }
             catch {
                 if (signal.aborted)
@@ -171,7 +279,7 @@ export function useChatStream(params) {
                 await sleep(2_000, signal);
             }
         }
-    }, [origin, refs, applySseBlock]);
+    }, [origin, refs, applySseBlock, thread.reconcileTurnStates]);
     const startEventsStream = useCallback((sessionId, generation) => {
         const existing = refs.eventsStreamStateRef.current;
         if (existing?.sessionId === sessionId &&
@@ -207,20 +315,7 @@ export function useChatStream(params) {
         }
         throw new Error("事件连接未就绪，请检查 Console 连接后重试");
     }, [refs, startEventsStream]);
-    const fetchSessionState = useCallback(async (sessionId) => {
-        try {
-            const res = await fetch(operatorChatStateUrl(origin, sessionId), {
-                credentials: "include",
-            });
-            const body = (await res.json().catch(() => ({})));
-            if (!res.ok)
-                return null;
-            return body.state ?? null;
-        }
-        catch {
-            return null;
-        }
-    }, [origin]);
+    const fetchSessionState = useCallback((sessionId) => fetchReconciledSessionState(origin, sessionId), [origin]);
     const postCreateTurn = useCallback(async (input) => {
         try {
             // Resolve against the configured Console origin and fail closed if a
@@ -1000,20 +1095,20 @@ export function useChatStream(params) {
         const sessionId = session.sessionId;
         const sessionIdentity = { ...session };
         const generation = refs.sessionGenerationRef.current;
+        const stateReconcileAbort = new AbortController();
         let cancelled = false;
         let syncInFlight = null;
         const runSync = async () => {
             try {
-                const res = await fetch(operatorChatStateUrl(origin, sessionId), {
-                    credentials: "include",
+                const state = await fetchReconciledSessionState(origin, sessionId, {
+                    ownerSignal: stateReconcileAbort.signal,
                 });
-                const body = (await res.json().catch(() => ({})));
                 if (cancelled ||
-                    !res.ok ||
+                    !state ||
                     refs.sessionRef.current?.sessionId !== sessionId ||
                     refs.sessionGenerationRef.current !== generation)
                     return;
-                const state = body.state;
+                thread.reconcileTurnStates(state?.turnStates);
                 const pending = refs.pendingSubmissionRef.current;
                 // Pending ownership reconcile. Controller owns bind/release; same
                 // clientRequestId only. Re-enter after acceptedTurnId so terminal
@@ -1158,6 +1253,7 @@ export function useChatStream(params) {
         void sync().finally(scheduleStopRetry);
         return () => {
             cancelled = true;
+            stateReconcileAbort.abort();
             window.clearInterval(interval);
             if (stopRetryTimer !== undefined)
                 window.clearTimeout(stopRetryTimer);
@@ -1174,6 +1270,7 @@ export function useChatStream(params) {
         markIdleIfCurrent,
         releaseSubmitOwnership,
         postAbortForTurn,
+        thread.reconcileTurnStates,
     ]);
     // Exactly one owner starts/aborts GET /events. Switching sessions or
     // recovering a cursor aborts the prior stream before the next one is made.