@tea-agent/loop-agent 0.39.0-next.3 → 0.39.0-next.31

package/dist/worker/console/static-src/operator-chat/open-preview-in-browser.js

@@ -0,0 +1,328 @@
+/** Shown near the preview header when window.open is blocked or Blob/URL creation fails. */
+export const PREVIEW_OPEN_POPUP_BLOCKED = "无法在浏览器中打开：弹窗被拦截";
+export const PREVIEW_TRUNCATION_NOTICE = "内容已截断，以下为已加载片段。";
+/** Window features that force a real OS window instead of a browser tab.
+ *  Do not include `noopener` here: browsers then return null even on success. */
+export function previewOpenWindowFeatures(input) {
+    const availWidth = input?.availWidth ?? 1440;
+    const availHeight = input?.availHeight ?? 900;
+    const width = Math.min(1280, Math.max(880, Math.floor(availWidth * 0.82)));
+    const height = Math.min(960, Math.max(640, Math.floor(availHeight * 0.88)));
+    return [
+        "popup=yes",
+        `width=${width}`,
+        `height=${height}`,
+        "left=72",
+        "top=36",
+        "menubar=yes",
+        "toolbar=yes",
+        "location=yes",
+        "status=yes",
+        "resizable=yes",
+        "scrollbars=yes",
+    ].join(",");
+}
+export function escapeHtml(text) {
+    return text
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function normalizedLanguage(language) {
+    return language.trim().toLowerCase();
+}
+export function isHtmlPreviewLanguage(language) {
+    const lang = normalizedLanguage(language);
+    return lang === "html" || lang === "htm";
+}
+export function isMarkdownPreviewLanguage(language) {
+    const lang = normalizedLanguage(language);
+    return lang === "md" || lang === "markdown";
+}
+function formatTextBody(preview) {
+    if (normalizedLanguage(preview.language) !== "json")
+        return preview.content;
+    try {
+        return JSON.stringify(JSON.parse(preview.content), null, 2);
+    }
+    catch {
+        return preview.content;
+    }
+}
+function isSafeHttpHref(href) {
+    return /^https?:\/\//i.test(href.trim());
+}
+function renderMarkdownInline(text) {
+    const withCode = [];
+    const coded = text.replace(/`([^`]+)`/g, (_all, code) => {
+        withCode.push(`<code>${code}</code>`);
+        return `\u0000${withCode.length - 1}\u0000`;
+    });
+    const linked = coded.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_all, label, href) => {
+        if (!isSafeHttpHref(href))
+            return label;
+        return `<a href="${href}" rel="noopener noreferrer" target="_blank">${label}</a>`;
+    });
+    const emphasized = linked
+        .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
+        .replace(/__([^_]+)__/g, "<strong>$1</strong>")
+        .replace(/\*([^*]+)\*/g, "<em>$1</em>");
+    return emphasized.replace(/\u0000(\d+)\u0000/g, (_all, idx) => {
+        return withCode[Number(idx)] ?? "";
+    });
+}
+function flushParagraph(lines) {
+    if (!lines.length)
+        return "";
+    return `<p>${renderMarkdownInline(lines.join(" "))}</p>`;
+}
+function renderMarkdownBlocks(escaped) {
+    const lines = escaped.replaceAll("\r\n", "\n").split("\n");
+    const out = [];
+    let paragraph = [];
+    let listKind = null;
+    const closeList = () => {
+        if (listKind) {
+            out.push(listKind === "ul" ? "</ul>" : "</ol>");
+            listKind = null;
+        }
+    };
+    const closeParagraph = () => {
+        if (paragraph.length) {
+            out.push(flushParagraph(paragraph));
+            paragraph = [];
+        }
+    };
+    for (const line of lines) {
+        const heading = /^(#{1,6})\s+(.+)$/.exec(line);
+        if (heading) {
+            closeParagraph();
+            closeList();
+            const level = heading[1].length;
+            out.push(`<h${level}>${renderMarkdownInline(heading[2])}</h${level}>`);
+            continue;
+        }
+        if (/^---+$/.test(line.trim()) || /^\*\*\*+$/.test(line.trim())) {
+            closeParagraph();
+            closeList();
+            out.push("<hr>");
+            continue;
+        }
+        const quote = /^&gt;\s?(.*)$/.exec(line);
+        if (quote) {
+            closeParagraph();
+            closeList();
+            out.push(`<blockquote><p>${renderMarkdownInline(quote[1] ?? "")}</p></blockquote>`);
+            continue;
+        }
+        const ul = /^[-*]\s+(.+)$/.exec(line);
+        if (ul) {
+            closeParagraph();
+            if (listKind !== "ul") {
+                closeList();
+                out.push("<ul>");
+                listKind = "ul";
+            }
+            out.push(`<li>${renderMarkdownInline(ul[1])}</li>`);
+            continue;
+        }
+        const ol = /^\d+\.\s+(.+)$/.exec(line);
+        if (ol) {
+            closeParagraph();
+            if (listKind !== "ol") {
+                closeList();
+                out.push("<ol>");
+                listKind = "ol";
+            }
+            out.push(`<li>${renderMarkdownInline(ol[1])}</li>`);
+            continue;
+        }
+        if (line.trim() === "") {
+            closeParagraph();
+            closeList();
+            continue;
+        }
+        closeList();
+        paragraph.push(line);
+    }
+    closeParagraph();
+    closeList();
+    return out.join("\n");
+}
+/** Conservative Markdown → HTML for the detached reading tab. Input is escaped first. */
+export function renderMarkdownLite(source) {
+    const escaped = escapeHtml(source);
+    const chunks = [];
+    const fence = /```([^\n`]*)\n([\s\S]*?)```/g;
+    let last = 0;
+    let match;
+    while ((match = fence.exec(escaped))) {
+        if (match.index > last) {
+            chunks.push(renderMarkdownBlocks(escaped.slice(last, match.index)));
+        }
+        chunks.push(`<pre class="md-code"><code>${match[2] ?? ""}</code></pre>`);
+        last = match.index + match[0].length;
+    }
+    if (last < escaped.length) {
+        chunks.push(renderMarkdownBlocks(escaped.slice(last)));
+    }
+    return chunks.filter(Boolean).join("\n");
+}
+function readingPageCss() {
+    return `
+:root { color-scheme: light dark; }
+html, body { margin: 0; min-height: 100%; background: #f7f5f0; color: #1f1b16; }
+body { font: 16px/1.65 ui-sans-serif, system-ui, -apple-system, "Segoe UI", sans-serif; }
+.bar { position: sticky; top: 0; z-index: 1; display: flex; gap: 12px; align-items: center; padding: 10px 16px 10px 20px; border-bottom: 1px solid #e4ddd2; background: #fffdf8; }
+.bar .meta { min-width: 0; flex: 1; display: flex; flex-direction: column; gap: 2px; }
+.bar strong { font-size: 13px; font-weight: 650; word-break: break-all; }
+.bar .kind { color: #6b6258; font-size: 12px; }
+.modes { display: inline-flex; gap: 2px; padding: 2px; border: 1px solid #e4ddd2; border-radius: 8px; background: #f3eee6; }
+.modes button { appearance: none; border: 0; background: transparent; color: #6b6258; font: 12px/1.2 inherit; padding: 5px 10px; border-radius: 6px; cursor: pointer; }
+.modes button:hover { color: #1f1b16; }
+.modes button.is-active { background: #fff; color: #1f1b16; font-weight: 600; box-shadow: 0 1px 2px rgb(0 0 0 / 8%); }
+.notice { margin: 0; padding: 8px 20px; background: #fff6d8; color: #5c4b00; font-size: 13px; }
+.pane { display: none; }
+.pane.is-active { display: block; }
+.doc { max-width: 52rem; margin: 0 auto; padding: 32px 24px 96px; }
+.doc.md h1, .doc.md h2, .doc.md h3, .doc.md h4 { line-height: 1.25; margin: 1.4em 0 0.5em; }
+.doc.md h1 { font-size: 2rem; }
+.doc.md h2 { font-size: 1.45rem; }
+.doc.md p { margin: 0.8em 0; }
+.doc.md ul, .doc.md ol { margin: 0.6em 0; padding-left: 1.4em; }
+.doc.md blockquote { margin: 0.8em 0; padding: 0.2em 0.9em; border-left: 3px solid #d9cfc0; color: #4a433c; }
+.doc.md hr { border: 0; border-top: 1px solid #e4ddd2; margin: 1.6em 0; }
+.doc.md a { color: #0b57d0; }
+.doc.md code, .md-code, .source { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 0.92em; }
+.doc.md :not(pre) > code { padding: 0.1em 0.35em; border-radius: 4px; background: #efe8dc; }
+.md-code, .source { margin: 1em 0; padding: 14px 16px; overflow: auto; white-space: pre-wrap; background: #fff; border: 1px solid #e4ddd2; border-radius: 8px; }
+.frame { margin: 0; padding: 0; }
+iframe.page { display: block; width: 100%; height: calc(100vh - 53px); border: 0; background: #fff; }
+`.trim();
+}
+function formattedSource(preview) {
+    return escapeHtml(formatTextBody(preview));
+}
+function previewPane(preview) {
+    if (isHtmlPreviewLanguage(preview.language)) {
+        return `<div class="frame"><iframe class="page" sandbox="" srcdoc="${escapeHtml(preview.content)}"></iframe></div>`;
+    }
+    if (isMarkdownPreviewLanguage(preview.language)) {
+        return `<article class="doc md">${renderMarkdownLite(preview.content)}</article>`;
+    }
+    return `<article class="doc"><pre class="source">${formattedSource(preview)}</pre></article>`;
+}
+function sourcePane(preview) {
+    return `<article class="doc"><pre class="source">${formattedSource(preview)}</pre></article>`;
+}
+function readingPageScript() {
+    return `<script>
+(function () {
+  var previewBtn = document.getElementById("view-preview");
+  var sourceBtn = document.getElementById("view-source");
+  var previewPane = document.getElementById("pane-preview");
+  var sourcePane = document.getElementById("pane-source");
+  if (!previewBtn || !sourceBtn || !previewPane || !sourcePane) return;
+  function show(mode) {
+    var source = mode === "source";
+    previewBtn.classList.toggle("is-active", !source);
+    sourceBtn.classList.toggle("is-active", source);
+    previewBtn.setAttribute("aria-pressed", String(!source));
+    sourceBtn.setAttribute("aria-pressed", String(source));
+    previewPane.classList.toggle("is-active", !source);
+    sourcePane.classList.toggle("is-active", source);
+  }
+  previewBtn.addEventListener("click", function () { show("preview"); });
+  sourceBtn.addEventListener("click", function () { show("source"); });
+})();
+</script>`;
+}
+/** Build the Blob document HTML from the already-loaded preview snapshot. */
+export function buildPreviewBrowserDocument(preview) {
+    const title = escapeHtml(preview.path);
+    const notice = preview.truncated
+        ? `<p class="notice">${escapeHtml(PREVIEW_TRUNCATION_NOTICE)}</p>`
+        : "";
+    const lang = normalizedLanguage(preview.language);
+    return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>
+${readingPageCss()}
+</style>
+</head>
+<body>
+<header class="bar">
+  <div class="meta">
+    <strong>${title}</strong>
+    <span class="kind">${escapeHtml(lang || "text")}${preview.truncated ? " · 已截断" : ""}</span>
+  </div>
+  <div class="modes" role="group" aria-label="查看模式">
+    <button type="button" id="view-preview" class="is-active" aria-pressed="true">预览</button>
+    <button type="button" id="view-source" aria-pressed="false">查看原文</button>
+  </div>
+</header>
+${notice}
+<div id="pane-preview" class="pane is-active">${previewPane(preview)}</div>
+<div id="pane-source" class="pane">${sourcePane(preview)}</div>
+${readingPageScript()}
+</body>
+</html>`;
+}
+function screenAvail() {
+    const screen = globalThis.screen;
+    return {
+        availWidth: screen?.availWidth,
+        availHeight: screen?.availHeight,
+    };
+}
+function defaultHost() {
+    const g = globalThis;
+    if (typeof g.open !== "function") {
+        throw new Error("window.open is unavailable");
+    }
+    return {
+        open: g.open.bind(g),
+        createObjectURL: g.URL.createObjectURL.bind(g.URL),
+        revokeObjectURL: g.URL.revokeObjectURL.bind(g.URL),
+    };
+}
+/**
+ * Open the current preview in a new OS window from already-loaded
+ * path/content/language/truncated. Does not fetch the repo file API again.
+ *
+ * Width/height window features ask the browser for a real window, not a tab.
+ * Do not pass `noopener` as a feature: browsers then return null even on
+ * success. Detach via `opener = null` after a real handle is obtained. Keep
+ * the Blob URL alive — revoking immediately blanks the page.
+ */
+export function openPreviewInBrowser(preview, host = defaultHost(), features = previewOpenWindowFeatures(screenAvail())) {
+    let objectUrl;
+    try {
+        const documentHtml = buildPreviewBrowserDocument(preview);
+        const blob = new Blob([documentHtml], { type: "text/html;charset=utf-8" });
+        objectUrl = host.createObjectURL(blob);
+        const opened = host.open(objectUrl, "_blank", features);
+        if (!opened) {
+            host.revokeObjectURL(objectUrl);
+            return { ok: false, error: PREVIEW_OPEN_POPUP_BLOCKED };
+        }
+        try {
+            opened.opener = null;
+        }
+        catch {
+            // Some hosts expose a frozen handle; the window is still open.
+        }
+        return { ok: true };
+    }
+    catch {
+        if (objectUrl)
+            host.revokeObjectURL(objectUrl);
+        return { ok: false, error: PREVIEW_OPEN_POPUP_BLOCKED };
+    }
+}

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,48 @@
  * 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.
+ */
+export function decideSubmissionRoute(input) {
+    if (input.turnPhase === "stopping") {
+        return input.blockedByTurnId
+            ? {
+                action: "queue-deferred",
+                blockedByTurnId: input.blockedByTurnId,
+            }
+            : { action: "hold" };
+    }
+    return input.turnPhase === "idle" ? { action: "send-now" } : { action: "hold" };
+}
+/**
+ * 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

@@ -5,6 +5,7 @@ import { hydrateSessionThread } from "../../chat/turn-process.js";
 import { ACTIVE_CHAT_SESSION_STORAGE_KEY } from "../../chat/workspace-landing.js";
 import { CHAT_SESSION_LIST_LIMIT } from "../chat-view-types.js";
 import { confirmationToken } from "./format.js";
+import { describeMutationGateFailure, isMutationGateFailureCode, isStaleTokenFailure, } from "./mutation-gate.js";
 import { SessionTitleWatcher } from "./session-title-watcher.js";
 export async function createSessionAndPrimeTitleWatcher(input) {
     if (input.creatingRef?.current) {
@@ -69,6 +70,8 @@ export function useChatSessions(params) {
     // Shared busy gate for sidebar + Landing create entries (one render feedback).
     const [creatingSession, setCreatingSession] = useState(false);
     const creatingSessionRef = useRef(false);
+    /** One-shot guard so a stale-token failure schedules a single page reload. */
+    const compactReloadScheduledRef = useRef(false);
     // Only the latest activate/create/restore intent may commit active-session
     // state. This prevents slow responses from an older selection overwriting a
     // newer user choice.
@@ -215,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);
@@ -396,6 +402,18 @@ export function useChatSessions(params) {
             });
             const body = (await response.json().catch(() => ({})));
             if (!response.ok) {
+                const gateCode = body.error?.code;
+                if (isMutationGateFailureCode(gateCode)) {
+                    // Stale boot tokens: the page predates the current server boot.
+                    // Auto-reload once so the fresh boot page re-injects tokens; keep
+                    // an error line up while reloading in case reload is blocked.
+                    setError(describeMutationGateFailure(gateCode));
+                    if (isStaleTokenFailure(gateCode) && !compactReloadScheduledRef.current) {
+                        compactReloadScheduledRef.current = true;
+                        window.setTimeout(() => window.location.reload(), 1200);
+                    }
+                    return;
+                }
                 setError(body.error?.message ?? "上下文压缩失败");
                 return;
             }