@tea-agent/loop-agent 0.39.0-next.8 → 0.39.0

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

@@ -0,0 +1,204 @@
+/**
+ * Resource-panel diagnostics presentation.
+ *
+ * Pi ResourceLoader emits machine English (`warning` / `collision` + full
+ * Windows paths). The Skills / Packages / Models panels must not dump that
+ * block above the inventory — it pushes the list off-screen. Classify here,
+ * then render a header chip + grouped popover with natural Chinese copy.
+ */
+const COLLISION_NAME = /name\s+"([^"]+)"\s+collision/i;
+const INVALID_CHARS = /invalid characters|must be lowercase/i;
+const INVALID_EDGE_HYPHEN = /must not start or end with a hyphen/i;
+const INVALID_DOUBLE_HYPHEN = /consecutive hyphens/i;
+const GROUP_COPY = {
+    "load-failed": {
+        heading: "需要处理",
+        hint: "有些清单没读完整，下面的列表可能不全。",
+    },
+    "invalid-name": {
+        heading: "名称不规范",
+        hint: "技能已经加载，还能用。名称请改成小写字母、数字和连字符，例如 sdd-requirement-analysis。",
+    },
+    collision: {
+        heading: "同名未生效",
+        hint: "同名技能只保留先扫到的那一份，后面的不会进当前会话。",
+    },
+    other: {
+        heading: "其他提示",
+        hint: "不影响你浏览当前列表。",
+    },
+};
+const GROUP_ORDER = [
+    "load-failed",
+    "invalid-name",
+    "collision",
+    "other",
+];
+export function shortResourcePath(path) {
+    if (!path)
+        return undefined;
+    const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+    if (parts.length === 0)
+        return path;
+    const file = parts.at(-1);
+    if (!file)
+        return path;
+    const parent = parts.at(-2);
+    return parent ? `${parent}/${file}` : file;
+}
+export function skillNameFromPath(path) {
+    if (!path)
+        return undefined;
+    const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+    if (parts.length === 0)
+        return undefined;
+    const last = parts.at(-1);
+    if (!last)
+        return undefined;
+    if (/^skill\.md$/i.test(last) && parts.length >= 2) {
+        return parts.at(-2);
+    }
+    return last.replace(/\.md$/i, "");
+}
+export function diagnosticMatchesSkill(item, skill) {
+    if (item.path) {
+        const left = item.path.replace(/\\/g, "/").toLowerCase();
+        const right = skill.path.replace(/\\/g, "/").toLowerCase();
+        if (left === right || left.endsWith(right) || right.endsWith(left)) {
+            return true;
+        }
+    }
+    return Boolean(item.skillName && item.skillName === skill.name);
+}
+function shortenMessage(message) {
+    const trimmed = message.trim();
+    if (trimmed.length <= 80)
+        return trimmed;
+    return `${trimmed.slice(0, 79)}…`;
+}
+function titleForLoadFailed(diag) {
+    const hay = `${diag.code ?? ""} ${diag.message}`.toLowerCase();
+    if (hay.includes("preference"))
+        return "自动使用偏好读不出来";
+    if (hay.includes("package"))
+        return "软件包清单没读完整";
+    if (hay.includes("skill"))
+        return "技能清单没读完整";
+    if (hay.includes("extension"))
+        return "扩展没读完整";
+    if (hay.includes("prompt"))
+        return "提示词没读完整";
+    if (hay.includes("theme"))
+        return "主题没读完整";
+    if (hay.includes("context"))
+        return "上下文文件没读完整";
+    return "有些内容没读完整";
+}
+function detailForInvalidName(message) {
+    if (INVALID_DOUBLE_HYPHEN.test(message)) {
+        return "名称里不要连用两个连字符。现在这样也能用。";
+    }
+    if (INVALID_EDGE_HYPHEN.test(message)) {
+        return "名称开头和结尾不要用连字符。现在这样也能用。";
+    }
+    return "名称请只用小写字母、数字和连字符。现在这样也能用。";
+}
+export function classifyResourceDiagnostic(diag) {
+    const type = (diag.type ?? "warning").toLowerCase();
+    const message = diag.message ?? "";
+    const collisionMatch = message.match(COLLISION_NAME) ??
+        (type === "collision" ? message.match(/"([^"]+)"/) : null);
+    if (type === "collision" || collisionMatch) {
+        const skillName = collisionMatch?.[1] ?? skillNameFromPath(diag.path);
+        return {
+            kind: "collision",
+            tone: "warning",
+            title: skillName ? `「${skillName}」有多份` : "有一份同名技能没生效",
+            detail: "同名只保留先扫到的那一份，这份被盖掉了。",
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            skillName,
+            retryable: false,
+        };
+    }
+    if (INVALID_CHARS.test(message) ||
+        INVALID_EDGE_HYPHEN.test(message) ||
+        INVALID_DOUBLE_HYPHEN.test(message)) {
+        const skillName = skillNameFromPath(diag.path);
+        return {
+            kind: "invalid-name",
+            tone: "warning",
+            title: skillName ?? "有个技能名称不合规范",
+            detail: detailForInvalidName(message),
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            skillName,
+            retryable: false,
+        };
+    }
+    const isLoadFailed = type === "error" ||
+        diag.retryable === true ||
+        diag.code === "RESOURCE_LOAD_FAILED" ||
+        diag.code === "PACKAGE_INVENTORY_FAILED" ||
+        diag.code === "PI_RESOURCE_PREFERENCES_MALFORMED";
+    if (isLoadFailed) {
+        return {
+            kind: "load-failed",
+            tone: "error",
+            title: titleForLoadFailed(diag),
+            detail: shortenMessage(message),
+            path: diag.path,
+            shortPath: shortResourcePath(diag.path),
+            retryable: diag.retryable === true,
+        };
+    }
+    return {
+        kind: "other",
+        tone: type === "error" ? "error" : "warning",
+        title: shortenMessage(message) || "一条提示",
+        path: diag.path,
+        shortPath: shortResourcePath(diag.path),
+        retryable: false,
+    };
+}
+export function summarizeResourceDiagnostics(diagnostics) {
+    const items = diagnostics.map(classifyResourceDiagnostic);
+    const buckets = new Map();
+    for (const item of items) {
+        const list = buckets.get(item.kind) ?? [];
+        list.push(item);
+        buckets.set(item.kind, list);
+    }
+    const groups = GROUP_ORDER.flatMap((kind) => {
+        const groupItems = buckets.get(kind);
+        if (!groupItems?.length)
+            return [];
+        return [{ kind, ...GROUP_COPY[kind], items: groupItems }];
+    });
+    const errorCount = items.filter((item) => item.tone === "error").length;
+    const warningCount = items.length - errorCount;
+    return {
+        total: items.length,
+        errorCount,
+        warningCount,
+        chipLabel: chipLabel(errorCount, warningCount),
+        groups,
+    };
+}
+function chipLabel(errorCount, warningCount) {
+    if (errorCount > 0 && warningCount > 0) {
+        return `${errorCount} 个问题 · ${warningCount} 条提示`;
+    }
+    if (errorCount > 0) {
+        return errorCount === 1 ? "1 个问题" : `${errorCount} 个问题`;
+    }
+    if (warningCount === 1)
+        return "1 条提示";
+    return `${warningCount} 条提示`;
+}
+export function skillHasNameWarning(skill, items) {
+    return items.some((item) => item.kind === "invalid-name" && diagnosticMatchesSkill(item, skill));
+}
+export function noticesForSkill(skill, items) {
+    return items.filter((item) => item.kind !== "collision" && diagnosticMatchesSkill(item, skill));
+}

package/dist/worker/console/static-src/operator-chat/turn-stream-controller.js

@@ -31,6 +31,13 @@ export function operatorChatEventsUrl(origin, sessionId) {
 export function operatorChatAbortUrl(origin, sessionId, turnId) {
     return `${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(sessionId)}/turns/${encodeURIComponent(turnId)}/abort`;
 }
+export function turnPhaseFromOwnership(bag) {
+    if (bag.stoppingTurnId || bag.stopRequested)
+        return "stopping";
+    if (bag.activeTurnId || bag.streaming || bag.submitInFlight || bag.pendingSubmission)
+        return "running";
+    return "idle";
+}
 export function createTurnOwnershipBag(seed) {
     return {
         submitInFlight: false,
@@ -53,7 +60,7 @@ export function createTurnOwnershipBag(seed) {
 }
 /** Whether a second concurrent send is blocked by ownership / busy. */
 export function isSubmitOwnershipBusy(bag) {
-    return bag.streaming || bag.submitInFlight || Boolean(bag.pendingSubmission);
+    return turnPhaseFromOwnership(bag) !== "idle";
 }
 /**
  * Release submit ownership. Optionally scoped to a clientRequestId so a stale

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

@@ -3,6 +3,60 @@
  * Extracted so double-submit, TURN_ACTIVE adoption, transport ambiguity, and
  * generation fences can be unit-tested without mounting the full React tree.
  */
+/**
+ * Choose the submission path from the mutable ownership facts, never from a
+ * possibly stale React render. A stopping intent without a bound Turn must
+ * remain held until reconciliation binds or releases that ownership.
+ *
+ * Since 2026-08-23 a running Turn also accepts a queued follow-up: Enter
+ * mid-turn binds the message to the active Turn (blockedByTurnId) and the
+ * server auto-dispatches it when the Turn settles or aborts.
+ */
+export function decideSubmissionRoute(input) {
+    if (input.turnPhase === "stopping") {
+        return input.blockedByTurnId
+            ? {
+                action: "queue-deferred",
+                blockedByTurnId: input.blockedByTurnId,
+            }
+            : { action: "hold" };
+    }
+    if (input.turnPhase === "running") {
+        return input.blockedByTurnId
+            ? {
+                action: "queue-deferred",
+                blockedByTurnId: input.blockedByTurnId,
+            }
+            : { action: "hold" };
+    }
+    return { action: "send-now" };
+}
+/**
+ * Reconcile a deferred PUT that raced with Stop completion. The same
+ * clientRequestId may move to the normal POST path only after authoritative
+ * state proves that no Turn/runtime remains busy.
+ */
+export function reconcileDeferredSubmissionFromState(input) {
+    const { clientRequestId, blockedByTurnId, state } = input;
+    if (!state)
+        return { action: "hold" };
+    if (state.deferredTurn?.clientRequestId === clientRequestId) {
+        return { action: "deferred", deferredTurn: state.deferredTurn };
+    }
+    if (state.activeTurn?.clientRequestId === clientRequestId) {
+        return { action: "accepted", turn: state.activeTurn };
+    }
+    if (state.latestTurn?.clientRequestId === clientRequestId) {
+        return { action: "accepted", turn: state.latestTurn };
+    }
+    const activeTurnId = state.activeTurn?.turnId ?? state.activeTurnId ?? null;
+    if (state.turnPhase === "stopping" && activeTurnId === blockedByTurnId) {
+        return { action: "retry-deferred" };
+    }
+    if (!isRuntimeBusyUnion(state))
+        return { action: "send-now" };
+    return { action: "hold" };
+}
 export function createPendingSubmission(input) {
     let resolveOutcome;
     const outcomePromise = new Promise((resolve) => {

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

@@ -218,6 +218,9 @@ export function useChatSessions(params) {
                 messages: hydrated.messages,
                 toolCalls: hydrated.toolCalls,
                 streaming: Boolean(body.session.activeTurnId),
+                turnPhase: body.session.turnPhase ??
+                    (body.session.activeTurnId ? "running" : "idle"),
+                deferredTurn: body.session.deferredTurn ?? null,
             });
             window.localStorage.setItem(ACTIVE_CHAT_SESSION_STORAGE_KEY, sessionId);
             setActivePreviewPath(null);

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

@@ -1,8 +1,8 @@
 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";
+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, } from "./turn-stream-controller.js";
 /** Project ChatRefs into the executable ownership bag used by the controller. */
 function ownershipBagFromRefs(refs) {
     return {
@@ -57,8 +57,8 @@ function clearEmptyAssistant(setMessages, assistantId) {
  * detached Turn resource only; it never opens a second inline SSE consumer. */
 export function useChatStream(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 { applySseBlock, setMessages, setStreaming, setStreamingAssistantId, streaming, setTurnPhase, setDeferredTurn, } = thread;
+    const { setInput, setPendingImages, recordHistory } = composer;
     const showNotice = useCallback((message) => {
         if (!setNotice)
             return;
@@ -78,9 +78,10 @@ export function useChatStream(params) {
         refs.assistantIdRef.current = null;
         refs.stoppingTurnIdRef.current = null;
         setStreaming(false);
+        setTurnPhase("idle");
         setStreamingAssistantId(null);
         clearEmptyAssistant(setMessages, assistantId);
-    }, [refs, setStreaming, setStreamingAssistantId, setMessages]);
+    }, [refs, setStreaming, setTurnPhase, 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
@@ -242,9 +243,13 @@ export function useChatStream(params) {
     /** 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);
+        // Optimistic visual stop: remove the running spinner immediately, but
+        // retain ownership as `stopping` until the server proves a terminal state.
+        // This keeps the composer responsive without falsely advertising idle.
+        refs.streamingRef.current = false;
+        setStreaming(false);
+        setTurnPhase("stopping");
+        setStreamingAssistantId(null);
         try {
             const res = await fetch(operatorChatAbortUrl(origin, sessionId, turnId), {
                 method: "POST",
@@ -278,6 +283,7 @@ export function useChatStream(params) {
                     markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
                 });
                 applyOwnershipBagToRefs(refs, bag);
+                setTurnPhase(turnPhaseFromOwnership(bag));
                 return;
             }
             applyAbortDecision(bag, decision, noticeSink(), {
@@ -285,6 +291,11 @@ export function useChatStream(params) {
                 markIdle: () => markIdleIfCurrent(sessionId, generation, refs.assistantIdRef.current),
             });
             applyOwnershipBagToRefs(refs, bag);
+            setTurnPhase(turnPhaseFromOwnership(bag));
+            // Sync the post-decision busy state back to React: optimistic stop
+            // flipped it idle up front; pending/keep-busy outcomes restore it.
+            if (bag.streaming)
+                setStreaming(true);
         }
         catch {
             // Abort network failure: keep busy (UIS-abort-network-fail).
@@ -297,11 +308,17 @@ export function useChatStream(params) {
                 networkError: true,
             }), noticeSink());
             applyOwnershipBagToRefs(refs, bag);
+            // Network failure: the optimistic idle was premature — restore busy
+            // so the turn is not silently dropped; /state reconcile converges.
+            refs.streamingRef.current = true;
+            setStreaming(true);
+            setTurnPhase("stopping");
         }
     }, [
         origin,
         refs,
         setStreaming,
+        setTurnPhase,
         markIdleIfCurrent,
         fetchSessionState,
         noticeSink,
@@ -351,10 +368,12 @@ export function useChatStream(params) {
             },
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase(turnPhaseFromOwnership(bag));
     }, [
         refs,
         noticeSink,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
         setPendingImages,
         watchSessionTitle,
@@ -363,20 +382,212 @@ export function useChatStream(params) {
         setError,
         postAbortForTurn,
     ]);
+    const queueDeferredTurn = useCallback(async (input) => {
+        const activeSession = refs.sessionRef.current;
+        if (!activeSession || (!input.text.trim() && input.images.length === 0))
+            return { action: "handled" };
+        const existing = thread.deferredTurn;
+        showNotice("正在排队…");
+        const acceptDeferred = (deferredTurn) => {
+            setDeferredTurn(deferredTurn);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice(existing ? "已更新排队消息" : "已排队，将在当前回合结束后自动发送");
+        };
+        const acceptDispatched = () => {
+            setDeferredTurn(null);
+            setInput("");
+            setPendingImages([]);
+            setError(null);
+            showNotice("消息已进入发送");
+        };
+        const putOnce = async () => {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    text: input.text,
+                    images: input.images,
+                    ...(existing ? { expectedRevision: existing.revision } : {}),
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            return { response, body };
+        };
+        try {
+            for (let attempt = 0; attempt < 2; attempt += 1) {
+                const { response, body } = await putOnce();
+                if (response.ok && body.accepted && body.deferredTurn) {
+                    acceptDeferred(body.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (body.deferredTurn)
+                    setDeferredTurn(body.deferredTurn);
+                if (body.error?.code !== "TURN_NOT_ACTIVE") {
+                    setError(body.error?.message ??
+                        `待发送消息未被服务端接受（HTTP ${response.status}）`);
+                    return { action: "handled" };
+                }
+                const canonical = await fetchSessionState(activeSession.sessionId);
+                const decision = reconcileDeferredSubmissionFromState({
+                    clientRequestId: input.clientRequestId,
+                    blockedByTurnId: input.blockedByTurnId,
+                    state: canonical ?? undefined,
+                });
+                if (decision.action === "deferred") {
+                    acceptDeferred(decision.deferredTurn);
+                    return { action: "handled" };
+                }
+                if (decision.action === "accepted") {
+                    acceptDispatched();
+                    return { action: "handled" };
+                }
+                if (decision.action === "retry-deferred" && attempt === 0)
+                    continue;
+                if (decision.action === "send-now" && !existing) {
+                    showNotice("上一轮已停止，正在发送当前消息…");
+                    return { action: "send-now" };
+                }
+                setError(body.error?.message ?? "停止状态已变化，当前消息仍保留在输入框");
+                return { action: "handled" };
+            }
+            return { action: "handled" };
+        }
+        catch (error) {
+            const canonical = await fetchSessionState(activeSession.sessionId);
+            const decision = reconcileDeferredSubmissionFromState({
+                clientRequestId: input.clientRequestId,
+                blockedByTurnId: input.blockedByTurnId,
+                state: canonical ?? undefined,
+            });
+            if (decision.action === "deferred") {
+                acceptDeferred(decision.deferredTurn);
+                return { action: "handled" };
+            }
+            if (decision.action === "accepted") {
+                acceptDispatched();
+                return { action: "handled" };
+            }
+            if (decision.action === "send-now" && !existing) {
+                showNotice("上一轮已停止，正在发送当前消息…");
+                return { action: "send-now" };
+            }
+            setError(error instanceof Error
+                ? `无法确认消息是否已排队：${error.message}`
+                : "无法确认消息是否已排队，请刷新后查看服务端状态");
+            return { action: "handled" };
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+        fetchSessionState,
+    ]);
+    /** DELETE the queued turn; "restore" moves its text back into the composer,
+     *  "discard" drops it entirely (2026-08-23 queue chip actions). */
+    const requestDeferredTurnDelete = useCallback(async (mode) => {
+        const activeSession = refs.sessionRef.current;
+        const deferred = thread.deferredTurn;
+        if (!activeSession || !deferred)
+            return;
+        try {
+            const response = await fetch(`${origin}/api/operator/v1/chat/sessions/${encodeURIComponent(activeSession.sessionId)}/deferred-turn`, {
+                method: "DELETE",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-loop-console-confirmation": confirmationToken(),
+                },
+                credentials: "include",
+                body: JSON.stringify({
+                    clientRequestId: deferred.clientRequestId,
+                    expectedRevision: deferred.revision,
+                }),
+            });
+            const body = (await response.json().catch(() => ({})));
+            if (!response.ok || !body.cancelled) {
+                setError(body.error?.message ?? "待发送消息撤回失败");
+                return;
+            }
+            setDeferredTurn(null);
+            if (mode === "restore") {
+                setInput(body.deferredTurn?.text ?? "");
+                setPendingImages(body.deferredTurn?.images ?? []);
+                showNotice("待发送消息已移回输入框");
+            }
+            else {
+                showNotice("已删除排队消息");
+            }
+            setError(null);
+        }
+        catch (error) {
+            setError(error instanceof Error ? error.message : String(error));
+        }
+    }, [
+        origin,
+        refs,
+        thread.deferredTurn,
+        setDeferredTurn,
+        setInput,
+        setPendingImages,
+        setError,
+        showNotice,
+    ]);
+    const cancelDeferredTurn = useCallback(() => requestDeferredTurnDelete("restore"), [requestDeferredTurnDelete]);
+    const discardDeferredTurn = useCallback(() => requestDeferredTurnDelete("discard"), [requestDeferredTurnDelete]);
     const sendPrompt = useCallback(async (text, images) => {
+        const initialSession = refs.sessionRef.current;
+        if (!initialSession || (!text.trim() && images.length === 0))
+            return;
+        const ownership = ownershipBagFromRefs(refs);
+        const route = decideSubmissionRoute({
+            turnPhase: turnPhaseFromOwnership(ownership),
+            blockedByTurnId: ownership.stoppingTurnId ?? ownership.activeTurnId,
+        });
+        const clientRequestId = requestId("chat-submit");
+        if (route.action === "hold") {
+            const phase = turnPhaseFromOwnership(ownership);
+            if (phase === "stopping")
+                showNotice("正在确认上一轮停止状态，当前消息已保留");
+            else if (phase === "running")
+                showNotice("正在确认当前回合状态，当前消息已保留");
+            return;
+        }
+        recordHistory?.(text);
+        if (route.action === "queue-deferred") {
+            const deferred = await queueDeferredTurn({
+                text,
+                images,
+                clientRequestId,
+                blockedByTurnId: route.blockedByTurnId,
+            });
+            if (deferred.action !== "send-now")
+                return;
+        }
         const activeSession = refs.sessionRef.current;
         const generation = refs.sessionGenerationRef.current;
         if (!activeSession ||
+            activeSession.sessionId !== initialSession.sessionId ||
             (!text.trim() && images.length === 0) ||
             refs.streamingRef.current ||
             refs.submitInFlightRef.current ||
             // AC-R5-002: ownership lease blocks send until terminal release.
-            Boolean(refs.pendingSubmissionRef.current))
+            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();
@@ -424,6 +635,7 @@ export function useChatStream(params) {
         setAutoScroll(true);
         setError(null);
         refs.streamingRef.current = true;
+        setTurnPhase("running");
         refs.assistantIdRef.current = assistantId;
         setStreaming(true);
         setStreamingAssistantId(assistantId);
@@ -519,7 +731,10 @@ export function useChatStream(params) {
         setAutoScroll,
         setError,
         setStreaming,
+        setTurnPhase,
         setStreamingAssistantId,
+        queueDeferredTurn,
+        recordHistory,
     ]);
     const handleStop = useCallback(async () => {
         // AC-R5-001: durable stopRequested is set synchronously before any await so
@@ -535,6 +750,7 @@ export function useChatStream(params) {
             notice: noticeSink(),
         });
         applyOwnershipBagToRefs(refs, bag);
+        setTurnPhase("stopping");
         // Immediate abort already scheduled for a known turnId — coalesce via
         // abortPostedTurnIds; stopInFlight only gates concurrent in-flight POSTs.
         if (stopResult.abortedTurnId) {
@@ -643,6 +859,9 @@ export function useChatStream(params) {
                         },
                     });
                     applyOwnershipBagToRefs(refs, bag);
+                    setTurnPhase(turnPhaseFromOwnership(bag));
+                    if (state && "deferredTurn" in state)
+                        setDeferredTurn(state.deferredTurn ?? null);
                     if (result === "bound") {
                         // US-BUSY-ACTIVE-BOUND: keep streaming/busy with same id.
                         setStreaming(true);
@@ -742,6 +961,7 @@ export function useChatStream(params) {
         refs,
         session,
         streaming,
+        setTurnPhase,
         markIdleIfCurrent,
         releaseSubmitOwnership,
         postAbortForTurn,
@@ -763,5 +983,11 @@ export function useChatStream(params) {
             }
         };
     }, [session, recoveryVersion, refs, startEventsStream]);
-    return { sendPrompt, handleStop, openEventsStream };
+    return {
+        sendPrompt,
+        handleStop,
+        cancelDeferredTurn,
+        discardDeferredTurn,
+        openEventsStream,
+    };
 }