@tea-agent/loop-agent 0.39.1 → 0.40.0-next.10

package/dist/worker/console/static-src/app/useRecoveryConsole.js

@@ -1,8 +1,9 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { classifyRecoveryFact, consoleRecoveryCtas, partitionRecoveryCtas, recommendedRecoveryCtaId, } from "../../recovery-cta.js";
 import { buildRecoveryReason, isAutoRecoveryReason, pickDefaultRecoveryNodeId, pickDefaultRecoveryRunId, sortRecoveryNodeCandidates, } from "../../recovery-selection.js";
-import { postOperator, RECOVERY_FACT_LABEL, } from "./console-types.js";
+import { postOperator, scopedReadUrl, RECOVERY_FACT_LABEL, } from "./console-types.js";
 import { useRecoveryActions } from "./useRecoveryActions.js";
+import { applyCanonicalHref, buildInspectHref, } from "../shell/workspace-route.js";
 /** Recovery workspace: DAG-run / node candidate selection, fact-classified
  *  CTA lanes, structured reason prefill, plan preflight and gated reruns. */
 export function useRecoveryConsole(params) {
@@ -36,12 +37,12 @@ export function useRecoveryConsole(params) {
     const inspectPath = useCallback(() => {
         if (dagRunId.trim()) {
             // from=recovery 激活统一壳的对象上下文 chip 与显式返回路径
-            return `/inspect/#/dag/${encodeURIComponent(dagRunId.trim())}?from=recovery`;
+            return buildInspectHref(`/dag/${encodeURIComponent(dagRunId.trim())}`, "from=recovery");
         }
-        return "/inspect/#/";
+        return "/#/inspect";
     }, [dagRunId]);
     const openFullInspect = useCallback(() => {
-        window.location.assign(inspectPath());
+        applyCanonicalHref(inspectPath());
     }, [inspectPath]);
     /** Resolve DAG run id for inspect (side panel or full page). */
     const resolveDagRunForInspect = useCallback(async () => {
@@ -70,7 +71,7 @@ export function useRecoveryConsole(params) {
                 setDagRunId(resolvedDag);
                 setObserveLinkStatus("match");
                 setObserveLinkMessage(null);
-                setObserveUrl(`/inspect/#/dag/${encodeURIComponent(resolvedDag)}`);
+                setObserveUrl(buildInspectHref(`/dag/${encodeURIComponent(resolvedDag)}`));
                 return resolvedDag;
             }
             setOpError("尚未找到该任务的 DAG 运行，请稍后再打开检视");
@@ -97,7 +98,7 @@ export function useRecoveryConsole(params) {
         const resolved = await resolveDagRunForInspect();
         if (!resolved)
             return;
-        window.location.assign(`/inspect/#/dag/${encodeURIComponent(resolved)}?from=recovery`);
+        applyCanonicalHref(buildInspectHref(`/dag/${encodeURIComponent(resolved)}`, "from=recovery"));
     }, [resolveDagRunForInspect]);
     const loadRecoveryRuns = useCallback(async () => {
         setRecoveryRunsLoading(true);
@@ -107,7 +108,7 @@ export function useRecoveryConsole(params) {
             if (id)
                 qs.set("taskId", id);
             qs.set("limit", "40");
-            const res = await fetch(`/api/operator/v1/recovery/candidates?${qs.toString()}`, { credentials: "same-origin" });
+            const res = await fetch(scopedReadUrl(`/api/operator/v1/recovery/candidates?${qs.toString()}`), { credentials: "same-origin" });
             if (!res.ok) {
                 setRecoveryRuns([]);
                 return;
@@ -133,7 +134,7 @@ export function useRecoveryConsole(params) {
         }
         setRecoveryNodesLoading(true);
         try {
-            const res = await fetch(`/api/dag-runs/${encodeURIComponent(id)}`, {
+            const res = await fetch(scopedReadUrl(`/api/dag-runs/${encodeURIComponent(id)}`), {
                 credentials: "same-origin",
             });
             if (!res.ok) {
@@ -253,9 +254,7 @@ export function useRecoveryConsole(params) {
             if (!refreshRunStatus)
                 return;
             try {
-                const res = await fetch(`/api/dag-runs/${encodeURIComponent(runId)}`, {
-                    credentials: "same-origin",
-                });
+                const res = await fetch(scopedReadUrl(`/api/dag-runs/${encodeURIComponent(runId)}`), { credentials: "same-origin" });
                 if (!res.ok || cancelled)
                     return;
                 const runBody = (await res.json());

package/dist/worker/console/static-src/app/useRunProgress.js

@@ -1,5 +1,6 @@
 import { useEffect, useMemo, useState } from "react";
 import { isTerminalDagRun } from "../../inspect-split.js";
+import { scopedReadUrl } from "./console-types.js";
 import { summarizeRunProgress, } from "../pages/tasks/run-panel-progress.js";
 const RUN_PROGRESS_POLL_INTERVAL_MS = 5000;
 /**
@@ -18,7 +19,7 @@ export function useRunProgress(dagRunId) {
         let timer;
         const load = async () => {
             try {
-                const response = await fetch(`/api/dag-runs/${encodeURIComponent(runId)}`, { credentials: "same-origin", signal: controller.signal });
+                const response = await fetch(scopedReadUrl(`/api/dag-runs/${encodeURIComponent(runId)}`), { credentials: "same-origin", signal: controller.signal });
                 if (!response.ok)
                     return;
                 const body = (await response.json());

package/dist/worker/console/static-src/app/useTaskWizard.js

@@ -1,9 +1,9 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { ensureUniqueDocumentNames, operatorRequestFits, operatorRequestTooLargeMessage, } from "../prd-file-import.js";
-import { requestId, WORKFLOW_OPTIONS, } from "./console-types.js";
+import { requestId, scopedReadUrl, WORKFLOW_OPTIONS, } from "./console-types.js";
 export async function fetchLedgerSummary(taskId, fetchImpl) {
     const impl = fetchImpl ?? fetch;
-    const response = await impl(`/api/tasks/${encodeURIComponent(taskId)}/ledger`, { credentials: "same-origin" });
+    const response = await impl(scopedReadUrl(`/api/tasks/${encodeURIComponent(taskId)}/ledger`), { credentials: "same-origin" });
     if (!response.ok)
         return { ok: false };
     const summary = (await response.json());

package/dist/worker/console/static-src/night/useNightBoard.js

@@ -1,4 +1,5 @@
 import { useCallback, useEffect, useState } from "react";
+import { scopedReadUrl } from "../app/console-types.js";
 /** Night board data plane: schedules list + doctor report + task pool +
  *  foreground aux-ticker projection, loaded together on mount/refresh. */
 export function useNightBoard(params) {
@@ -16,10 +17,12 @@ export function useNightBoard(params) {
         setLoadError(null);
         try {
             const [jobsRes, doctorRes, tasksRes, tickerRes] = await Promise.all([
-                fetch("/api/night-jobs", { credentials: "same-origin" }),
-                fetch("/api/night-jobs/doctor", { credentials: "same-origin" }),
-                fetch("/api/tasks", { credentials: "same-origin" }),
-                fetch("/api/operator/v1/night-aux-ticker", {
+                fetch(scopedReadUrl("/api/night-jobs"), { credentials: "same-origin" }),
+                fetch(scopedReadUrl("/api/night-jobs/doctor"), {
+                    credentials: "same-origin",
+                }),
+                fetch(scopedReadUrl("/api/tasks"), { credentials: "same-origin" }),
+                fetch(scopedReadUrl("/api/operator/v1/night-aux-ticker"), {
                     credentials: "same-origin",
                 }),
             ]);
@@ -59,7 +62,7 @@ export function useNightBoard(params) {
     }, [refreshBoard]);
     const onMorningReport = useCallback(async () => {
         try {
-            const res = await fetch("/api/night-jobs/morning", {
+            const res = await fetch(scopedReadUrl("/api/night-jobs/morning"), {
                 credentials: "same-origin",
             });
             if (!res.ok) {

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

@@ -3,6 +3,7 @@ import { humanGateCardFromEventPayload, mergeHumanGateCardState, } from "../../c
 import { mergeOperationCardState, operationFromEventPayload, } from "../../chat/operation-card.js";
 import { requestId } from "./format.js";
 import { parseAssistantContent } from "../../chat/assistant-content.js";
+import { upsertCompactionMessage } from "./compaction-message.js";
 /** Shared handler for a single parsed Chat SSE event (M1 reconnect).
  *
  * Used by BOTH the inline prompt POST SSE and the background reconnect
@@ -10,7 +11,9 @@ import { parseAssistantContent } from "../../chat/assistant-content.js";
  * original request would have. `assistantId` is the in-flight assistant
  * message id to patch for streaming text; reconnect creates one if none. */
 export function createChatSseEventApplier(deps) {
-    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, setMessages, setToolCalls, } = deps;
+    const { refs, onReconcile, setError, setInterview, setHumanGateCards, setArtifactCards, setStreaming, setTurnPhase = () => undefined, setDeferredTurn = () => undefined, setDeferredTurns = () => undefined, setStreamingAssistantId, setUnread, setOperationCards, setUsage, onTelemetryRefresh, setMessages, setToolCalls, setPendingQuestion = () => undefined, setTodos = () => undefined, } = deps;
+    let queueOwner;
+    let queueRevision = -1;
     return (eventName, data, assistantId, options) => {
         if (options?.generation !== undefined &&
             refs.sessionGenerationRef.current !== options.generation)
@@ -42,6 +45,26 @@ export function createChatSseEventApplier(deps) {
         const payload = data.data && typeof data.data === "object"
             ? data.data
             : data;
+        if (eventName === "todo_updated" || eventName === "todo_cleared") {
+            const todos = Array.isArray(payload.todos) ? payload.todos : [];
+            setTodos(todos.filter((item) => Boolean(item) && typeof item === "object" && typeof item.content === "string" && (item.status === "pending" || item.status === "in_progress" || item.status === "completed")));
+            return;
+        }
+        if ((eventName === "question_requested" ||
+            eventName === "question_resolved" ||
+            eventName === "question_cancelled") &&
+            payload.question &&
+            typeof payload.question === "object") {
+            const question = payload.question;
+            if (typeof question.requestId === "string" &&
+                typeof question.sessionId === "string" &&
+                question.sessionId === refs.sessionRef.current?.sessionId) {
+                setPendingQuestion(eventName === "question_requested" && question.status === "pending"
+                    ? question
+                    : null);
+            }
+            return;
+        }
         const turnId = typeof data.turnId === "string" ? data.turnId : undefined;
         const eventSeq = typeof data.seq === "number" && Number.isFinite(data.seq)
             ? data.seq
@@ -51,13 +74,20 @@ export function createChatSseEventApplier(deps) {
             : Date.now();
         if (eventName === "queue_update") {
             const revision = typeof payload.revision === "number" ? payload.revision : -1;
-            setDeferredTurn((current) => {
-                if (current && revision < current.revision)
-                    return current;
-                return payload.deferredTurn && typeof payload.deferredTurn === "object"
-                    ? payload.deferredTurn
-                    : null;
-            });
+            const owner = refs.sessionRef.current?.sessionId;
+            if (owner !== queueOwner) {
+                queueOwner = owner;
+                queueRevision = -1;
+            }
+            if (revision < queueRevision)
+                return;
+            queueRevision = revision;
+            setDeferredTurn(payload.deferredTurn && typeof payload.deferredTurn === "object"
+                ? payload.deferredTurn
+                : null);
+            if (Array.isArray(payload.deferredTurns)) {
+                setDeferredTurns(payload.deferredTurns);
+            }
             return;
         }
         if (eventName === "user_message") {
@@ -84,6 +114,17 @@ export function createChatSseEventApplier(deps) {
             }
             return;
         }
+        if (eventName === "compact" ||
+            eventName === "compaction_start" ||
+            eventName === "compaction_end") {
+            setMessages((messages) => upsertCompactionMessage(messages, {
+                eventId: typeof data.eventId === "string" ? data.eventId : undefined,
+                kind: eventName,
+                at: new Date(eventAt).toISOString(),
+                data: payload,
+            }));
+            return;
+        }
         if (turnId &&
             (eventName === "agent_start" || eventName === "message_update") &&
             refs.settledTurnIdsRef.current.has(turnId)) {
@@ -186,6 +227,16 @@ export function createChatSseEventApplier(deps) {
                 refs.settledTurnIdsRef.current.delete(turnId);
                 refs.activeTurnIdRef.current = turnId;
             }
+            if (refs.stopRequestedRef.current &&
+                (!turnId ||
+                    turnId === refs.stoppingTurnIdRef.current ||
+                    turnId === refs.activeTurnIdRef.current)) {
+                refs.streamingRef.current = false;
+                setStreaming(false);
+                setTurnPhase("idle");
+                setStreamingAssistantId(null);
+                return;
+            }
             refs.streamingRef.current = true;
             setStreaming(true);
             setTurnPhase("running");
@@ -200,9 +251,22 @@ export function createChatSseEventApplier(deps) {
             // (M4.4). It must not prematurely close the visible turn.
             if (eventName === "agent_end")
                 return;
+            const pending = refs.pendingSubmissionRef.current;
+            if (pending && turnId && pending.acceptedTurnId === turnId) {
+                refs.releasedClientRequestIdsRef.current.add(pending.clientRequestId);
+                refs.pendingSubmissionRef.current = null;
+                refs.submitInFlightRef.current = false;
+            }
+            if (!turnId ||
+                turnId === refs.stoppingTurnIdRef.current ||
+                turnId === refs.activeTurnIdRef.current) {
+                refs.stoppingTurnIdRef.current = null;
+                refs.stopRequestedRef.current = false;
+            }
             if (turnId === refs.activeTurnIdRef.current)
                 refs.activeTurnIdRef.current = null;
             refs.streamingRef.current = false;
+            refs.assistantIdRef.current = null;
             setStreaming(false);
             setTurnPhase("idle");
             setStreamingAssistantId(null);
@@ -236,10 +300,21 @@ export function createChatSseEventApplier(deps) {
                     return true;
                 return assistantOwnsTools;
             }));
+            if (!replay)
+                onTelemetryRefresh?.();
             return;
         }
         if (eventName === "operation-ref" || eventName === "operation-status") {
             const operation = operationFromEventPayload(payload);
+            // R9: tombstones are session-scoped. The same operation may be linked
+            // to another session, but delayed frames cannot resurrect it here.
+            const currentSessionId = refs.sessionRef.current?.sessionId;
+            if (operation &&
+                currentSessionId &&
+                refs.unlinkedOperationIdsRef.current
+                    .get(currentSessionId)
+                    ?.has(operation.operationId))
+                return;
             if (operation) {
                 const toolCallId = typeof payload.toolCallId === "string"
                     ? payload.toolCallId
@@ -256,6 +331,23 @@ export function createChatSseEventApplier(deps) {
             }
             return;
         }
+        if (eventName === "operation-unlinked") {
+            // R8 AC-001/AC-R8-001: durable tombstone — the server persisted an
+            // operation-unlinked event that OVERSHADOWS any earlier operation-ref.
+            // Drop the card from the projection; replay/recovery can never
+            // resurrect it because the tombstone is appended after the ref in
+            // the same ring.
+            const operationId = typeof payload.operationId === "string" ? payload.operationId : "";
+            const currentSessionId = refs.sessionRef.current?.sessionId;
+            if (operationId && currentSessionId) {
+                const sessionTombstones = refs.unlinkedOperationIdsRef.current.get(currentSessionId) ??
+                    new Set();
+                sessionTombstones.add(operationId);
+                refs.unlinkedOperationIdsRef.current.set(currentSessionId, sessionTombstones);
+                setOperationCards((current) => current.filter((card) => card.operationId !== operationId));
+            }
+            return;
+        }
         if (eventName === "usage") {
             if (replay)
                 return;
@@ -451,6 +543,47 @@ export function createChatSseEventApplier(deps) {
             });
         }
         else if (eventName === "error") {
+            const candidate = payload.providerError && typeof payload.providerError === "object"
+                ? payload.providerError
+                : undefined;
+            if (candidate &&
+                typeof candidate.message === "string" &&
+                typeof candidate.raw === "string" &&
+                (candidate.category === "authentication" ||
+                    candidate.category === "context-overflow" ||
+                    candidate.category === "rate-limit" ||
+                    candidate.category === "provider")) {
+                // Session hydration already restores the durable card; retained replay
+                // must not add a second synthetic row on top of it.
+                if (replay)
+                    return;
+                const providerError = candidate;
+                const errorContent = parseAssistantContent(payload.content);
+                const id = turnId && eventSeq !== undefined
+                    ? `provider-error-${turnId}-${eventSeq}`
+                    : requestId("provider-error");
+                setMessages((messages) => {
+                    if (messages.some((message) => message.id === id))
+                        return messages;
+                    const activeAlreadyOwnsContent = messages.some((message) => message.id === resolvedAssistantId &&
+                        Boolean(message.content?.length));
+                    return [
+                        ...messages,
+                        {
+                            id,
+                            role: "assistant",
+                            kind: "provider-error",
+                            text: providerError.message,
+                            createdAt: eventAt,
+                            providerError,
+                            ...(!activeAlreadyOwnsContent && errorContent
+                                ? { content: errorContent }
+                                : {}),
+                        },
+                    ];
+                });
+                return;
+            }
             setError(typeof payload.message === "string" ? payload.message : "chat error");
         }
     };

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

@@ -0,0 +1,79 @@
+function finiteToken(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? Math.max(0, Math.floor(value))
+        : undefined;
+}
+/** Project legacy final snapshots and lifecycle events to one stable row. */
+export function compactionMessageFromEvent(item) {
+    const data = item.data && typeof item.data === "object"
+        ? item.data
+        : {};
+    const eventId = typeof item.eventId === "string" ? item.eventId : undefined;
+    const compactionId = typeof data.compactionId === "string" && data.compactionId
+        ? data.compactionId
+        : eventId;
+    if (!compactionId)
+        return undefined;
+    const status = data.status === "running" ||
+        data.status === "completed" ||
+        data.status === "failed" ||
+        data.status === "aborted"
+        ? data.status
+        : "completed";
+    const reason = data.reason === "manual" ||
+        data.reason === "threshold" ||
+        data.reason === "overflow"
+        ? data.reason
+        : "manual";
+    const summary = typeof data.summary === "string" ? data.summary : "";
+    const errorMessage = typeof data.errorMessage === "string" ? data.errorMessage : undefined;
+    return {
+        id: `compaction-${compactionId}`,
+        role: "assistant",
+        kind: "compaction",
+        text: summary ||
+            errorMessage ||
+            (status === "completed"
+                ? "历史上下文已精简，关键决策与当前任务已保留。"
+                : ""),
+        createdAt: Date.parse(item.at ?? "") || Date.now(),
+        compaction: {
+            compactionId,
+            status,
+            reason,
+            willRetry: data.willRetry === true,
+            ...(finiteToken(data.tokensBefore) === undefined
+                ? {}
+                : { tokensBefore: finiteToken(data.tokensBefore) }),
+            ...(finiteToken(data.estimatedTokensAfter) === undefined
+                ? {}
+                : { estimatedTokensAfter: finiteToken(data.estimatedTokensAfter) }),
+            ...(typeof data.firstKeptEntryId === "string" && data.firstKeptEntryId
+                ? { firstKeptEntryId: data.firstKeptEntryId }
+                : {}),
+            ...(errorMessage ? { errorMessage } : {}),
+            ...(eventId ? { eventId } : {}),
+        },
+    };
+}
+export function upsertCompactionMessage(messages, item) {
+    const next = compactionMessageFromEvent(item);
+    if (!next)
+        return messages;
+    const existing = messages.find((message) => message.id === next.id);
+    const result = existing
+        ? messages.map((message) => message.id === next.id
+            ? {
+                ...message,
+                ...next,
+                createdAt: Math.min(message.createdAt, next.createdAt),
+                text: next.text || message.text,
+                compaction: {
+                    ...message.compaction,
+                    ...next.compaction,
+                },
+            }
+            : message)
+        : [...messages, next];
+    return result.sort((a, b) => a.createdAt - b.createdAt);
+}

package/dist/worker/console/static-src/operator-chat/details-dag-actions.js

@@ -0,0 +1,122 @@
+function resolveDagId(id) {
+    const value = typeof id === "function" ? id() : id;
+    return value?.trim() || null;
+}
+export function createDetailsDagActions(params) {
+    const fetchImpl = params.fetchFn ?? fetch;
+    let pending = false;
+    let error = null;
+    const completionListeners = new Set();
+    const emitState = () => params.onStateChange?.({ pending, error });
+    const emitCompletion = (outcome, identity, message) => {
+        for (const listener of [...completionListeners]) {
+            try {
+                listener(outcome, identity, message);
+            }
+            catch {
+                // a listener throwing must never break the request path
+            }
+        }
+    };
+    const run = (action, issue) => {
+        const sessionId = resolveDagId(params.sessionId);
+        const operationId = resolveDagId(params.operationId);
+        if (!sessionId || !operationId || pending)
+            return false;
+        const identity = {
+            action,
+            workspaceId: resolveDagId(params.workspaceId ?? null),
+            sessionId,
+            operationId,
+        };
+        pending = true;
+        error = null;
+        emitState();
+        void (async () => {
+            try {
+                const result = await issue(identity);
+                if (!result.ok) {
+                    error = result.message ?? `DAG 关联操作失败`;
+                    params.onFailure?.(identity, error);
+                    emitCompletion("failure", identity, error);
+                    return;
+                }
+                params.onSuccess?.(identity);
+                emitCompletion("success", identity);
+            }
+            catch (err) {
+                error = err instanceof Error ? err.message : String(err);
+                params.onFailure?.(identity, error);
+                emitCompletion("failure", identity, error);
+            }
+            finally {
+                pending = false;
+                emitState();
+            }
+        })();
+        return true;
+    };
+    return {
+        get pending() {
+            return pending;
+        },
+        get error() {
+            return error;
+        },
+        subscribe(listener) {
+            completionListeners.add(listener);
+            return () => completionListeners.delete(listener);
+        },
+        onAddDag() {
+            return run("add", async (identity) => {
+                // AC-002: session-scoped mutations carry the session's durable
+                // owning workspace so a global active-workspace switch can never
+                // retarget the link to another workspace's store.
+                const ownerQuery = identity.workspaceId
+                    ? `?workspaceId=${encodeURIComponent(identity.workspaceId)}`
+                    : "";
+                const res = await fetchImpl(`/api/operator/v1/chat/sessions/${encodeURIComponent(identity.sessionId)}/operation-links${ownerQuery}`, {
+                    method: "POST",
+                    credentials: "same-origin",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-loop-console-confirmation": params.confirmationToken(),
+                    },
+                    body: JSON.stringify({ operationId: identity.operationId }),
+                });
+                if (!res.ok) {
+                    const body = (await res.json().catch(() => ({})));
+                    return {
+                        ok: false,
+                        message: body.error?.message ??
+                            `添加 DAG 关联失败（HTTP ${res.status}）`,
+                    };
+                }
+                return { ok: true };
+            });
+        },
+        onRemoveDag() {
+            return run("remove", async (identity) => {
+                const ownerQuery = identity.workspaceId
+                    ? `?workspaceId=${encodeURIComponent(identity.workspaceId)}`
+                    : "";
+                const res = await fetchImpl(`/api/operator/v1/chat/sessions/${encodeURIComponent(identity.sessionId)}/operation-links/${encodeURIComponent(identity.operationId)}${ownerQuery}`, {
+                    method: "DELETE",
+                    credentials: "same-origin",
+                    headers: {
+                        "x-loop-console-confirmation": params.confirmationToken(),
+                    },
+                });
+                if (!res.ok && res.status !== 404) {
+                    const body = (await res.json().catch(() => ({})));
+                    return {
+                        ok: false,
+                        message: body.error?.message ??
+                            `移除 DAG 关联失败（HTTP ${res.status}）`,
+                    };
+                }
+                return { ok: true };
+            });
+        },
+    };
+}

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

@@ -24,6 +24,7 @@ export function useChatRefs() {
     const abortPostedTurnIdsRef = useRef(new Set());
     const releasedClientRequestIdsRef = useRef(new Set());
     const usageResponseKeysRef = useRef(new Set());
+    const unlinkedOperationIdsRef = useRef(new Map());
     const isComposingRef = useRef(false);
     const compositionEndedAtRef = useRef(0);
     // Keep the bag identity stable: individual refs never change, so domain
@@ -53,6 +54,7 @@ export function useChatRefs() {
         abortPostedTurnIdsRef,
         releasedClientRequestIdsRef,
         usageResponseKeysRef,
+        unlinkedOperationIdsRef,
         isComposingRef,
         compositionEndedAtRef,
     }), [
@@ -80,6 +82,7 @@ export function useChatRefs() {
         abortPostedTurnIdsRef,
         releasedClientRequestIdsRef,
         usageResponseKeysRef,
+        unlinkedOperationIdsRef,
         isComposingRef,
         compositionEndedAtRef,
     ]);

package/dist/worker/console/static-src/operator-chat/runtime-selection-labels.js

@@ -0,0 +1,27 @@
+import { formatModelRef } from "../../chat/runtime-selection.js";
+const THINKING_SHORT_LABELS = {
+    auto: "Auto",
+    off: "Off",
+    minimal: "Minimal",
+    low: "Low",
+    medium: "Medium",
+    high: "High",
+    xhigh: "XHigh",
+    max: "Max",
+};
+export function formatThinkingSelectionLabel(selection, effective) {
+    const normalized = selection || "auto";
+    const label = THINKING_SHORT_LABELS[normalized] ?? normalized;
+    if (normalized !== "auto" || !effective)
+        return label;
+    return `${label} · ${THINKING_SHORT_LABELS[effective] ?? effective}`;
+}
+export function resolveModelDisplayName(models, activeModelRef) {
+    if (!activeModelRef)
+        return "选择模型";
+    const current = models.find((model) => formatModelRef(model.provider, model.id) === activeModelRef);
+    if (current)
+        return current.name?.trim() || current.id;
+    const slash = activeModelRef.indexOf("/");
+    return slash === -1 ? activeModelRef : activeModelRef.slice(slash + 1);
+}

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

@@ -1,6 +1,6 @@
 /**
  * Mutual-exclusion state for large spatial overlays in Operator Chat.
- * At most one of: sidebar drawer, process, runtime context, tools, activity.
+ * At most one of: sidebar drawer, process, runtime context, tools.
  * Small composer menus (model/thinking) are out of scope.
  */
 export function createSpatialOverlayState(active = "none") {
@@ -33,6 +33,5 @@ export function spatialOverlayFlags(state) {
         processOpen: state.active === "process",
         runtimeContextOpen: state.active === "runtime-context",
         toolsOpen: state.active === "tools",
-        activityOpen: state.active === "activity",
     };
 }