@tea-agent/loop-agent 0.44.0-next.5 → 0.44.0-next.7

package/dist/worker/console/static-src/operator-chat/useChatSessions.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)];
@@ -199,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);
@@ -257,46 +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 belongsToVisibleWorkspace = (item) => !item.workspaceId || visibleWorkspaceIds.has(item.workspaceId);
-            const durable = 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));
-            // Preserve summaries for visible workspaces. ChatWorkspaceSidebar applies
-            // the 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, visibleWorkspaceIds]);
+    }, []);
     const deleteSession = useCallback(async (sessionId) => {
         if (pendingDeletedIdsRef.current.has(sessionId))
             return false;
@@ -306,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
@@ -339,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);
@@ -410,6 +514,7 @@ export function useChatSessions(params) {
         setError,
         sessionOwnerQuery,
         workspaceId,
+        invalidateSessionListBaseline,
     ]);
     const forgetLostSession = useCallback((sessionId, ownerWorkspaceId) => {
         const active = refs.sessionRef.current;
@@ -422,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);
@@ -434,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;
@@ -501,10 +615,12 @@ 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 ??
@@ -541,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]);
@@ -637,10 +779,12 @@ 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 ??
@@ -696,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);
@@ -711,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) {
@@ -720,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)
@@ -902,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

@@ -3,8 +3,50 @@ 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 {
@@ -106,6 +148,17 @@ export function useChatStream(params) {
      * 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 ||
@@ -145,6 +198,16 @@ export function useChatStream(params) {
                         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") {
@@ -156,7 +219,7 @@ export function useChatStream(params) {
                                 break readLoop;
                             }
                         }
-                        if (sseEventName(block) === "stream_ready") {
+                        if (eventName === "stream_ready") {
                             const current = refs.eventsStreamStateRef.current;
                             if (current?.sessionId === sessionId &&
                                 current.generation === generation)
@@ -179,7 +242,7 @@ export function useChatStream(params) {
                             if (!replay)
                                 liveContinuityCursor = selectLaterChatEventId(liveContinuityCursor, eventId);
                         }
-                        if (sseEventName(block) === "stream_ready" &&
+                        if (eventName === "stream_ready" &&
                             gapReplayBuffer.length > 0) {
                             const repairedBlocks = selectChatSseRepairBlocks(gapReplayBuffer.splice(0), liveContinuityCursor);
                             for (const repairedBlock of repairedBlocks) {
@@ -193,6 +256,9 @@ export function useChatStream(params) {
                                 refs.lastEventIdRef.current = selectLaterChatEventId(refs.lastEventIdRef.current, repairedEventId);
                             }
                         }
+                        if (eventName === "stream_ready") {
+                            void turnStateReconciles.start();
+                        }
                     }
                 }
                 if (replayRepairNeeded) {
@@ -213,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 &&
@@ -249,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
@@ -1042,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
@@ -1200,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);
@@ -1216,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.