@tea-agent/loop-agent 0.34.3 → 0.34.4

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

@@ -1,6 +1,41 @@
 import { useCallback, useEffect } from "react";
 import { formatOperatorUserError } from "../../operator-user-error.js";
 import { confirmationToken, requestId, sleep } from "./format.js";
+import { classifyCreateTurnNetworkFailure, classifyCreateTurnResponse, createPendingSubmission, isRuntimeBusyUnion, isSubmissionCurrent, isTerminalTurnState, keepAmbiguousAfterRetry, reconcilePendingSubmissionFromState, resolveAmbiguousFromState, } from "./turn-submission.js";
+import { applyAbortDecision, applyPendingReconcileDecision, classifyAbortResponse, markStopRequested, operatorChatAbortUrl, operatorChatEventsUrl, operatorChatStateUrl, operatorChatTurnsUrl, releaseOwnershipOnTerminalEvidence, releaseSubmitOwnership as releaseOwnershipBag, requestStopOnOwnership, settleCreateTurnOutcome, } from "./turn-stream-controller.js";
+/** Project ChatRefs into the executable ownership bag used by the controller. */
+function ownershipBagFromRefs(refs) {
+    return {
+        submitInFlight: refs.submitInFlightRef.current,
+        pendingSubmission: refs.pendingSubmissionRef.current,
+        activeTurnId: refs.activeTurnIdRef.current,
+        streaming: refs.streamingRef.current,
+        assistantId: refs.assistantIdRef.current,
+        stoppingTurnId: refs.stoppingTurnIdRef.current,
+        settledTurnIds: refs.settledTurnIdsRef.current,
+        turnAssistantIds: refs.turnAssistantIdsRef.current,
+        sessionId: refs.sessionRef.current?.sessionId ?? null,
+        sessionGeneration: refs.sessionGenerationRef.current,
+        submitGeneration: refs.submitGenerationRef.current,
+        stopInFlight: refs.stopInFlightRef.current,
+        stopRequested: refs.stopRequestedRef.current,
+        abortPostedTurnIds: refs.abortPostedTurnIdsRef.current,
+        releasedClientRequestIds: refs.releasedClientRequestIdsRef.current,
+    };
+}
+/** Write controller bag mutations back onto ChatRefs (shared mutable backbone). */
+function applyOwnershipBagToRefs(refs, bag) {
+    refs.submitInFlightRef.current = bag.submitInFlight;
+    refs.pendingSubmissionRef.current = bag.pendingSubmission;
+    refs.activeTurnIdRef.current = bag.activeTurnId;
+    refs.streamingRef.current = bag.streaming;
+    refs.assistantIdRef.current = bag.assistantId;
+    refs.stoppingTurnIdRef.current = bag.stoppingTurnId;
+    // settledTurnIds / turnAssistantIds / abortPosted / released sets are same instances.
+    refs.submitGenerationRef.current = bag.submitGeneration;
+    refs.stopInFlightRef.current = bag.stopInFlight;
+    refs.stopRequestedRef.current = bag.stopRequested;
+}
 function sseEventName(block) {
     return (block
         .split("\n")
@@ -11,12 +46,41 @@ function sseEventName(block) {
 function sleepBriefly() {
     return new Promise((resolve) => window.setTimeout(resolve, 25));
 }
+function clearEmptyAssistant(setMessages, assistantId) {
+    if (!assistantId)
+        return;
+    setMessages((messages) => messages.filter((message) => !(message.id === assistantId &&
+        message.role === "assistant" &&
+        !message.text.trim())));
+}
 /** One GET /events stream owns all Chat events. Sending a prompt creates a
  * detached Turn resource only; it never opens a second inline SSE consumer. */
 export function useChatStream(params) {
-    const { origin, refs, session, thread, composer, setError, setAutoScroll, recoveryVersion = 0, watchSessionTitle, } = params;
+    const { origin, refs, session, thread, composer, setError, setAutoScroll, setNotice, recoveryVersion = 0, watchSessionTitle, } = params;
     const { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, } = thread;
     const { setInput, setPendingImages } = composer;
+    const showNotice = useCallback((message) => {
+        if (!setNotice)
+            return;
+        setNotice({ id: Date.now(), message });
+    }, [setNotice]);
+    const releaseSubmitOwnership = useCallback((pendingClientRequestId) => {
+        const bag = ownershipBagFromRefs(refs);
+        releaseOwnershipBag(bag, pendingClientRequestId);
+        applyOwnershipBagToRefs(refs, bag);
+    }, [refs]);
+    const markIdleIfCurrent = useCallback((sessionId, generation, assistantId) => {
+        if (refs.sessionRef.current?.sessionId !== sessionId ||
+            refs.sessionGenerationRef.current !== generation)
+            return;
+        refs.streamingRef.current = false;
+        refs.activeTurnIdRef.current = null;
+        refs.assistantIdRef.current = null;
+        refs.stoppingTurnIdRef.current = null;
+        setStreaming(false);
+        setStreamingAssistantId(null);
+        clearEmptyAssistant(setMessages, assistantId);
+    }, [refs, setStreaming, setStreamingAssistantId, setMessages]);
     /** Follow one session's event stream until it is explicitly aborted. The
      * server's `stream_ready` marker separates replay from live events; this
      * means replay cannot render duplicate messages while live text remains
@@ -36,7 +100,7 @@ export function useChatStream(params) {
                 const last = refs.lastEventIdRef.current;
                 if (last)
                     headers["Last-Event-ID"] = last;
-                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/events`, { headers, credentials: "include", signal });
+                const res = await fetch(operatorChatEventsUrl(origin, sessionId), { headers, credentials: "include", signal });
                 if (!res.ok || !res.body) {
                     if (res.status === 404)
                         return;
@@ -122,13 +186,212 @@ 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 postCreateTurn = useCallback(async (input) => {
+        try {
+            // Real create-turn path remains `${origin}/api/operator/v1/chat/sessions/:id/turns`
+            // (via operatorChatTurnsUrl); source contract anchors on /turns`.
+            const res = await fetch(operatorChatTurnsUrl(origin, input.sessionId), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: input.clientRequestId,
+                    text: input.text.trim() || "请查看附件图片。",
+                    images: input.images.map(({ type, mimeType, data }) => ({
+                        type,
+                        mimeType,
+                        data,
+                    })),
+                }),
+            });
+            const body = (await res.json().catch(() => ({})));
+            return { httpOk: res.ok, status: res.status, body };
+        }
+        catch {
+            return {
+                httpOk: false,
+                status: 0,
+                body: {},
+                networkError: true,
+            };
+        }
+    }, [origin]);
+    const noticeSink = useCallback(() => {
+        return {
+            showNotice,
+            setError: (message) => setError(message),
+        };
+    }, [showNotice, setError]);
+    /** Issue real POST /abort for a known turnId (Stop never disposes Session). */
+    const postAbortForTurn = useCallback(async (sessionId, generation, turnId) => {
+        refs.stoppingTurnIdRef.current = turnId;
+        // Keep streaming/busy while abort is in flight (UIS-stopping).
+        refs.streamingRef.current = true;
+        setStreaming(true);
+        try {
+            const res = await fetch(operatorChatAbortUrl(origin, sessionId, turnId), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: "{}",
+            });
+            const body = (await res.json().catch(() => ({})));
+            if (refs.sessionRef.current?.sessionId !== sessionId ||
+                refs.sessionGenerationRef.current !== generation)
+                return;
+            if (refs.stoppingTurnIdRef.current !== turnId)
+                return;
+            const decision = classifyAbortResponse({
+                httpOk: res.ok,
+                turnId,
+                body,
+            });
+            const bag = ownershipBagFromRefs(refs);
+            bag.stoppingTurnId = turnId;
+            if (decision.action === "owner-lost-reconcile") {
+                const state = await fetchSessionState(sessionId);
+                const stillCurrent = refs.sessionRef.current?.sessionId === sessionId &&
+                    refs.sessionGenerationRef.current === generation;
+                applyAbortDecision(bag, decision, noticeSink(), {
+                    sessionStillCurrent: stillCurrent,
+                    runtimeBusy: isRuntimeBusyUnion(state ?? undefined),
+                    markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
+                });
+                applyOwnershipBagToRefs(refs, bag);
+                return;
+            }
+            applyAbortDecision(bag, decision, noticeSink(), {
+                sessionStillCurrent: true,
+                markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
+            });
+            applyOwnershipBagToRefs(refs, bag);
+        }
+        catch {
+            // Abort network failure: keep busy (UIS-abort-network-fail).
+            // Notice only — never setError / never dispose Session.
+            const bag = ownershipBagFromRefs(refs);
+            applyAbortDecision(bag, classifyAbortResponse({
+                httpOk: false,
+                turnId,
+                body: {},
+                networkError: true,
+            }), noticeSink());
+            applyOwnershipBagToRefs(refs, bag);
+        }
+    }, [
+        origin,
+        refs,
+        setStreaming,
+        markIdleIfCurrent,
+        fetchSessionState,
+        noticeSink,
+    ]);
+    /** Production path: settle create-turn via the shared turn-stream controller. */
+    const settleOutcome = useCallback((outcome, ctx) => {
+        const bag = ownershipBagFromRefs(refs);
+        // Keep bag generation fields authoritative for isSubmissionCurrent.
+        bag.sessionId = refs.sessionRef.current?.sessionId ?? null;
+        bag.sessionGeneration = refs.sessionGenerationRef.current;
+        bag.submitGeneration = refs.submitGenerationRef.current;
+        const setPendingImagesUi = (images) => {
+            setPendingImages(images);
+        };
+        settleCreateTurnOutcome(bag, outcome, {
+            assistantId: ctx.assistantId,
+            text: ctx.text,
+            images: ctx.images,
+            pending: ctx.pending,
+            sessionId: ctx.sessionId,
+            notice: noticeSink(),
+            acceptedUi: {
+                setStreaming,
+                setStreamingAssistantId,
+                setPendingImages: setPendingImagesUi,
+                watchSessionTitle,
+            },
+            adoptUi: {
+                clearEmptyAssistant: (assistantId) => clearEmptyAssistant(setMessages, assistantId),
+                setInput,
+                setPendingImages: setPendingImagesUi,
+                setStreaming,
+                setStreamingAssistantId,
+            },
+            rejectedUi: {
+                setError,
+                setStreaming,
+                setStreamingAssistantId,
+                clearEmptyAssistant: (assistantId) => clearEmptyAssistant(setMessages, assistantId),
+                setInput,
+                setPendingImages: setPendingImagesUi,
+                formatError: formatOperatorUserError,
+            },
+            // AC-R5-001: durable stopRequested + accepted/adopt yields one abort.
+            onAutoAbort: (turnId) => {
+                void postAbortForTurn(ctx.sessionId, ctx.generation, turnId);
+            },
+        });
+        applyOwnershipBagToRefs(refs, bag);
+    }, [
+        refs,
+        noticeSink,
+        setStreaming,
+        setStreamingAssistantId,
+        setPendingImages,
+        watchSessionTitle,
+        setMessages,
+        setInput,
+        setError,
+        postAbortForTurn,
+    ]);
     const sendPrompt = useCallback(async (text, images) => {
         const activeSession = refs.sessionRef.current;
         const generation = refs.sessionGenerationRef.current;
         if (!activeSession ||
             (!text.trim() && images.length === 0) ||
-            refs.streamingRef.current)
+            refs.streamingRef.current ||
+            refs.submitInFlightRef.current ||
+            // AC-R5-002: ownership lease blocks send until terminal release.
+            Boolean(refs.pendingSubmissionRef.current))
             return;
+        // AC-001: acquire synchronous submit ownership before the first await.
+        refs.submitInFlightRef.current = true;
+        const submitGeneration = ++refs.submitGenerationRef.current;
+        const clientRequestId = requestId("chat-submit");
+        const userMessageId = requestId("u");
+        const assistantId = requestId("a");
+        const draftText = text.trim();
+        const draftImages = images.slice();
+        const pending = createPendingSubmission({
+            clientRequestId,
+            submitGeneration,
+            sessionId: activeSession.sessionId,
+            sessionGeneration: generation,
+            text: draftText,
+            images: draftImages,
+            assistantId,
+            userMessageId,
+        });
+        refs.pendingSubmissionRef.current = pending;
         try {
             await ensureEventsConnected(activeSession.sessionId, generation);
         }
@@ -137,138 +400,322 @@ export function useChatStream(params) {
                 refs.sessionGenerationRef.current === generation) {
                 setError(formatOperatorUserError(error instanceof Error ? error.message : String(error)));
             }
+            releaseSubmitOwnership(clientRequestId);
             return;
         }
         if (refs.sessionRef.current?.sessionId !== activeSession.sessionId ||
-            refs.sessionGenerationRef.current !== generation)
+            refs.sessionGenerationRef.current !== generation) {
+            releaseSubmitOwnership(clientRequestId);
             return;
+        }
         const userMsg = {
-            id: requestId("u"),
+            id: userMessageId,
             role: "user",
-            text: text.trim(),
+            text: draftText,
             createdAt: Date.now(),
         };
-        const assistantId = requestId("a");
         setMessages((messages) => [
             ...messages,
             userMsg,
             { id: assistantId, role: "assistant", text: "", createdAt: Date.now() },
         ]);
         setInput("");
+        // Attachments stay until accepted (AC/UIS-accepted).
         setAutoScroll(true);
         setError(null);
         refs.streamingRef.current = true;
         refs.assistantIdRef.current = assistantId;
         setStreaming(true);
         setStreamingAssistantId(assistantId);
-        const controller = new AbortController();
-        refs.abortRef.current = controller;
-        refs.sessionAbortControllersRef.current.set(activeSession.sessionId, controller);
-        try {
-            const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/turns`, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "x-loop-console-confirmation": confirmationToken(),
-                },
-                credentials: "include",
-                body: JSON.stringify({
-                    text: text.trim() || "请查看附件图片。",
-                    images: images.map(({ type, mimeType, data }) => ({
-                        type,
-                        mimeType,
-                        data,
-                    })),
-                }),
-                signal: controller.signal,
-            });
-            const body = (await res.json().catch(() => ({})));
-            if (!res.ok || !body.turnId)
-                throw new Error(body.error?.message ?? `HTTP ${res.status}`);
-            // A successful accepted turn is the browser-side authorization to
-            // watch this session's late automatic title. The watcher is independent
-            // of the active-session generation, so switching away does not lose it.
-            watchSessionTitle(activeSession.sessionId);
-            // Slow POST returns cannot alter a later selection/turn (M5.2).
-            if (refs.sessionRef.current?.sessionId !== activeSession.sessionId ||
-                refs.sessionGenerationRef.current !== generation)
-                return;
-            refs.activeTurnIdRef.current = body.turnId;
-            refs.turnAssistantIdsRef.current.set(body.turnId, assistantId);
-            setPendingImages([]);
+        const ctx = {
+            sessionId: activeSession.sessionId,
+            generation,
+            submitGeneration,
+            assistantId,
+            text: draftText,
+            images: draftImages,
+            pending,
+        };
+        const first = await postCreateTurn({
+            sessionId: activeSession.sessionId,
+            clientRequestId,
+            text: draftText,
+            images: draftImages,
+        });
+        if (!isSubmissionCurrent({
+            pending,
+            sessionId: refs.sessionRef.current?.sessionId,
+            sessionGeneration: refs.sessionGenerationRef.current,
+            submitGeneration: refs.submitGenerationRef.current,
+        })) {
+            pending.resolveOutcome({ kind: "stale" });
+            releaseSubmitOwnership(clientRequestId);
+            return;
         }
-        catch (error) {
-            if (error?.name !== "AbortError" &&
-                refs.sessionRef.current?.sessionId === activeSession.sessionId &&
-                refs.sessionGenerationRef.current === generation) {
-                setError(formatOperatorUserError(error instanceof Error ? error.message : String(error)));
-                refs.streamingRef.current = false;
-                refs.assistantIdRef.current = null;
-                setStreaming(false);
-                setStreamingAssistantId(null);
-                setMessages((messages) => messages.filter((message) => message.id !== assistantId || message.text.trim()));
+        let outcome = first.networkError
+            ? classifyCreateTurnNetworkFailure()
+            : classifyCreateTurnResponse({
+                httpOk: first.httpOk,
+                status: first.status,
+                body: first.body,
+                clientRequestId,
+            });
+        if (outcome.kind === "ambiguous") {
+            // AC-FIX-001: reconcile by clientRequestId; retry once with same id.
+            // Transport uncertainty never becomes rejected / idle.
+            const state = await fetchSessionState(activeSession.sessionId);
+            const fromState = state
+                ? resolveAmbiguousFromState({ clientRequestId, state })
+                : null;
+            if (fromState) {
+                outcome = fromState;
+            }
+            else {
+                const retry = await postCreateTurn({
+                    sessionId: activeSession.sessionId,
+                    clientRequestId,
+                    text: draftText,
+                    images: draftImages,
+                });
+                if (!isSubmissionCurrent({
+                    pending,
+                    sessionId: refs.sessionRef.current?.sessionId,
+                    sessionGeneration: refs.sessionGenerationRef.current,
+                    submitGeneration: refs.submitGenerationRef.current,
+                })) {
+                    pending.resolveOutcome({ kind: "stale" });
+                    releaseSubmitOwnership(clientRequestId);
+                    return;
+                }
+                outcome = retry.networkError
+                    ? classifyCreateTurnNetworkFailure("无法确认 Turn 是否已创建，正在与服务端对账（不会重复提交新的请求 ID）")
+                    : classifyCreateTurnResponse({
+                        httpOk: retry.httpOk,
+                        status: retry.status,
+                        body: retry.body,
+                        clientRequestId,
+                    });
+                if (outcome.kind === "ambiguous") {
+                    // Capture message before reassignment: `outcome` widens back to the full union.
+                    const ambiguousMessage = outcome.message ||
+                        "无法确认 Turn 是否已创建，正在与服务端对账（不会重复提交新的请求 ID）";
+                    outcome = keepAmbiguousAfterRetry(ambiguousMessage);
+                    showNotice(ambiguousMessage);
+                }
             }
         }
-        finally {
-            refs.sessionAbortControllersRef.current.delete(activeSession.sessionId);
-            if (refs.abortRef.current === controller)
-                refs.abortRef.current = null;
-        }
+        settleOutcome(outcome, ctx);
     }, [
         origin,
         refs,
         ensureEventsConnected,
+        postCreateTurn,
+        fetchSessionState,
+        settleOutcome,
+        releaseSubmitOwnership,
+        showNotice,
         setMessages,
         setInput,
         setAutoScroll,
         setError,
         setStreaming,
         setStreamingAssistantId,
-        setPendingImages,
-        watchSessionTitle,
     ]);
-    const handleStop = useCallback(() => {
-        refs.abortRef.current?.abort();
-        if (refs.activeTurnIdRef.current)
-            refs.settledTurnIdsRef.current.add(refs.activeTurnIdRef.current);
-        refs.streamingRef.current = false;
-        refs.activeTurnIdRef.current = null;
-        setStreaming(false);
-        setStreamingAssistantId(null);
-        setMessages((messages) => messages.filter((message) => !(message.id === refs.assistantIdRef.current &&
-            message.role === "assistant" &&
-            !message.text.trim())));
-        refs.assistantIdRef.current = null;
-    }, [refs, setStreaming, setStreamingAssistantId, setMessages]);
+    const handleStop = useCallback(async () => {
+        // AC-R5-001: durable stopRequested is set synchronously before any await so
+        // Stop during ambiguous create-turn is never lost. Stop never disposes Session.
+        const sessionId = refs.sessionRef.current?.sessionId;
+        const generation = refs.sessionGenerationRef.current;
+        if (!sessionId)
+            return;
+        const bag = ownershipBagFromRefs(refs);
+        // Decide + mark intent/coalesce only; POST is issued once below.
+        const stopResult = requestStopOnOwnership(bag, {
+            postAbort: () => { },
+            notice: noticeSink(),
+        });
+        applyOwnershipBagToRefs(refs, bag);
+        // Immediate abort already scheduled for a known turnId — coalesce via
+        // abortPostedTurnIds; stopInFlight only gates concurrent in-flight POSTs.
+        if (stopResult.abortedTurnId) {
+            if (refs.stopInFlightRef.current)
+                return;
+            refs.stopInFlightRef.current = true;
+            try {
+                await postAbortForTurn(sessionId, generation, stopResult.abortedTurnId);
+            }
+            finally {
+                refs.stopInFlightRef.current = false;
+            }
+            return;
+        }
+        // No turnId yet: durable stopRequested survives until accepted/adopt/bind.
+        // Optionally wait on outcomePromise so a racing accepted create still aborts
+        // even if settleOutcome's onAutoAbort races; abortPostedTurnIds coalesces.
+        const pending = refs.pendingSubmissionRef.current;
+        if (!pending)
+            return;
+        if (refs.stopInFlightRef.current)
+            return;
+        refs.stopInFlightRef.current = true;
+        try {
+            const outcome = await pending.outcomePromise;
+            if (refs.sessionRef.current?.sessionId !== sessionId ||
+                refs.sessionGenerationRef.current !== generation)
+                return;
+            let turnId = null;
+            if (outcome.kind === "accepted")
+                turnId = outcome.turnId;
+            else if (outcome.kind === "adopt-active")
+                turnId = outcome.activeTurn.turnId;
+            else if (outcome.kind === "ambiguous") {
+                // Intent remains; /state bind-active will fire exactly one abort.
+                return;
+            }
+            else {
+                // rejected / stale — clear durable intent (settle already released).
+                refs.stopRequestedRef.current = false;
+                return;
+            }
+            if (!turnId)
+                return;
+            // settleOutcome may already have auto-aborted; coalesce via bag.
+            const lateBag = ownershipBagFromRefs(refs);
+            markStopRequested(lateBag);
+            const late = requestStopOnOwnership(lateBag, {
+                postAbort: () => { },
+                notice: noticeSink(),
+            });
+            applyOwnershipBagToRefs(refs, lateBag);
+            if (late.abortedTurnId) {
+                await postAbortForTurn(sessionId, generation, late.abortedTurnId);
+            }
+        }
+        finally {
+            refs.stopInFlightRef.current = false;
+        }
+    }, [refs, noticeSink, postAbortForTurn]);
     // State reconciliation is only a status fence: it never consumes/creates
     // message events, and a generation check discards late responses (M5.3).
+    // Busy truth = durable activeTurn union runtime busy facts (AC-003/AC-006).
+    // AC-R3-001/002: while pendingSubmissionRef holds a clientRequestId after
+    // ambiguous double-POST, continuous /state must bind or release that same
+    // id only - never mint a new request id or re-POST Prompt.
+    // AC-R5-001/002: stopRequested auto-abort on bind; terminal evidence releases
+    // ownership even when React streaming is already false.
     useEffect(() => {
-        if (!session || !streaming)
+        // Keep reconcile alive while streaming OR pending ownership OR stop intent.
+        const hasOwnershipWork = Boolean(refs.pendingSubmissionRef.current) ||
+            refs.submitInFlightRef.current ||
+            refs.stopRequestedRef.current ||
+            Boolean(refs.activeTurnIdRef.current);
+        if (!session || (!streaming && !hasOwnershipWork))
             return;
         const sessionId = session.sessionId;
         const generation = refs.sessionGenerationRef.current;
         let cancelled = false;
         const sync = async () => {
             try {
-                const res = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/state`, { credentials: "include" });
+                const res = await fetch(operatorChatStateUrl(origin, sessionId), {
+                    credentials: "include",
+                });
                 const body = (await res.json().catch(() => ({})));
                 if (cancelled ||
                     !res.ok ||
                     refs.sessionRef.current?.sessionId !== sessionId ||
                     refs.sessionGenerationRef.current !== generation)
                     return;
-                const activeTurnId = body.state?.activeTurnId ?? null;
+                const state = body.state;
+                const pending = refs.pendingSubmissionRef.current;
+                // Pending ownership reconcile. Controller owns bind/release; same
+                // clientRequestId only. Re-enter after acceptedTurnId so terminal
+                // can release and stopRequested can auto-abort on bind.
+                if (pending) {
+                    const decision = reconcilePendingSubmissionFromState({
+                        clientRequestId: pending.clientRequestId,
+                        state,
+                    });
+                    const bag = ownershipBagFromRefs(refs);
+                    const result = applyPendingReconcileDecision(bag, decision, state, {
+                        markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
+                        onAutoAbort: (turnId) => {
+                            void postAbortForTurn(sessionId, generation, turnId);
+                        },
+                    });
+                    applyOwnershipBagToRefs(refs, bag);
+                    if (result === "bound") {
+                        // US-BUSY-ACTIVE-BOUND: keep streaming/busy with same id.
+                        setStreaming(true);
+                        return;
+                    }
+                    if (result === "released") {
+                        return;
+                    }
+                    // hold without acceptedTurnId: keep pending + busy.
+                    if (!pending.acceptedTurnId && !bag.pendingSubmission?.acceptedTurnId) {
+                        return;
+                    }
+                    // hold with acceptedTurnId: fall through to terminal fence.
+                }
+                const activeTurnId = state?.activeTurn?.turnId ?? state?.activeTurnId ?? null;
                 refs.activeTurnIdRef.current = activeTurnId;
-                if (activeTurnId !== null || !refs.streamingRef.current)
+                const busy = isRuntimeBusyUnion(state);
+                // AC-R5-002: terminal evidence releases ownership even when React
+                // streaming is already false (SSE projected idle first).
+                const stillPending = refs.pendingSubmissionRef.current;
+                if (stillPending) {
+                    const latestMatches = state?.latestTurn?.clientRequestId ===
+                        stillPending.clientRequestId &&
+                        isTerminalTurnState(state?.latestTurn?.state);
+                    const activeMatches = state?.activeTurn?.clientRequestId ===
+                        stillPending.clientRequestId &&
+                        isTerminalTurnState(state?.activeTurn?.state);
+                    if (latestMatches || activeMatches) {
+                        const termTurnId = activeMatches
+                            ? (state?.activeTurn?.turnId ?? null)
+                            : (state?.latestTurn?.turnId ??
+                                stillPending.acceptedTurnId ??
+                                null);
+                        const bag = ownershipBagFromRefs(refs);
+                        releaseOwnershipOnTerminalEvidence(bag, {
+                            clientRequestId: stillPending.clientRequestId,
+                            turnId: termTurnId,
+                            markIdle: !busy,
+                        });
+                        applyOwnershipBagToRefs(refs, bag);
+                        if (!busy) {
+                            markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current);
+                        }
+                        return;
+                    }
+                }
+                if (busy)
                     return;
+                // Only clear when durable Turn is gone AND runtime is not busy.
+                // Do not require streamingRef.current === true (AC-R5-002).
                 const assistantId = refs.assistantIdRef.current;
-                refs.streamingRef.current = false;
-                refs.assistantIdRef.current = null;
-                setStreaming(false);
-                setStreamingAssistantId(null);
-                setMessages((messages) => messages.filter((message) => !(message.id === assistantId &&
-                    message.role === "assistant" &&
-                    !message.text.trim())));
+                if (activeTurnId) {
+                    const terminal = isTerminalTurnState(state?.activeTurn?.state) ||
+                        isTerminalTurnState(state?.activeTurnState);
+                    if (!terminal)
+                        return;
+                }
+                if (activeTurnId)
+                    refs.settledTurnIdsRef.current.add(activeTurnId);
+                const releaseId = stillPending?.clientRequestId;
+                if (releaseId) {
+                    const bag = ownershipBagFromRefs(refs);
+                    releaseOwnershipOnTerminalEvidence(bag, {
+                        clientRequestId: releaseId,
+                        turnId: activeTurnId,
+                        markIdle: true,
+                    });
+                    applyOwnershipBagToRefs(refs, bag);
+                }
+                else {
+                    releaseSubmitOwnership();
+                }
+                markIdleIfCurrent(sessionId, generation, assistantId);
             }
             catch {
                 // offline/background case: interval, visibility and online retry.
@@ -282,6 +729,8 @@ export function useChatStream(params) {
         const interval = window.setInterval(() => void sync(), 15_000);
         document.addEventListener("visibilitychange", onVisible);
         window.addEventListener("online", onOnline);
+        // Immediate tick so terminal-before-streaming-false races converge promptly.
+        void sync();
         return () => {
             cancelled = true;
             window.clearInterval(interval);
@@ -293,9 +742,9 @@ export function useChatStream(params) {
         refs,
         session,
         streaming,
-        setStreaming,
-        setStreamingAssistantId,
-        setMessages,
+        markIdleIfCurrent,
+        releaseSubmitOwnership,
+        postAbortForTurn,
     ]);
     // Exactly one owner starts/aborts GET /events. Switching sessions or
     // recovering a cursor aborts the prior stream before the next one is made.