@tea-agent/loop-agent 0.39.0-beta.0 → 0.39.0-beta.10

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

@@ -17,21 +17,33 @@ const ACTION_PROGRESS_COPY = {
     spineCheck: "正在运行 Spine 审计…",
     dagGenerate: "正在生成 DAG…",
     standaloneTaskRerun: "正在带反馈重新执行任务：服务端校验资格后生成并启动新 DAG…",
+    consoleUpdateAndInit: "正在检查活动运行、所选 npm 渠道与安全初始化；完成后 Console 将自动刷新…",
     workerTaskRetry: "正在重新排队 Worker Task…",
 };
 /** Central operator-action dispatcher: POST /api/operator/v1/operations with
  *  polling, long-running background waits, interview payload handoff and the
  *  per-operation SSE follow log. */
 export function useOperatorActions(params) {
-    const { shell, applyInterviewPayload } = params;
+    const { shell, applyInterviewPayload, workspaceId } = params;
     const { setBusy, setOpError, setOpErrorCode, setOpMessage, setReadiness, setStep, setNav, setLastOpState, setLayers, step, nav, } = shell;
     const [operationId, setOperationId] = useState(null);
+    const [operationWorkspaceId, setOperationWorkspaceId] = useState(null);
     const [sseLog, setSseLog] = useState([]);
     const [followSse, setFollowSse] = useState(true);
     const sseAbort = useRef(null);
     const [confirmationId, setConfirmationId] = useState(null);
     const [confirmationDetails, setConfirmationDetails] = useState(null);
     const runAction = useCallback(async (action, actionParams = {}, opts) => {
+        const requestWorkspaceId = workspaceId?.trim() || null;
+        if (!requestWorkspaceId) {
+            const message = "当前 Workspace 不可用；请先选择有效 Workspace 后再执行操作";
+            setOpError(message);
+            setOpErrorCode("WORKSPACE_REQUIRED");
+            return {
+                ok: false,
+                error: { code: "WORKSPACE_REQUIRED", message },
+            };
+        }
         setBusy(true);
         setOpError(null);
         setOpErrorCode(null);
@@ -40,7 +52,7 @@ export function useOperatorActions(params) {
         // other UI feedback, which reads as a frozen page.
         setOpMessage(ACTION_PROGRESS_COPY[action] ?? null);
         try {
-            const { status, body } = await postOperator(action, actionParams, opts?.clientRequestId);
+            const { status, body } = await postOperator(action, actionParams, opts?.clientRequestId, requestWorkspaceId);
             if (status === 412 || body.error?.code === "PI_SETUP_REQUIRED") {
                 setOpError(formatOperatorUserError(body.error?.message ?? "Pi 未就绪或已降级：该操作暂不可用"));
                 setOpErrorCode(body.error?.code ?? "PI_SETUP_REQUIRED");
@@ -62,6 +74,7 @@ export function useOperatorActions(params) {
                 return body;
             }
             if (body.operationId) {
+                setOperationWorkspaceId(requestWorkspaceId ?? null);
                 const activeChatSessionId = window.localStorage
                     .getItem(ACTIVE_CHAT_SESSION_STORAGE_KEY)
                     ?.trim();
@@ -94,7 +107,7 @@ export function useOperatorActions(params) {
                     setOpMessage(`操作已接受，后台运行中：${body.operationId}（请看事件流；可同时打开 Observe）`);
                     // Recovery / long actions still need terminal feedback on this page.
                     const acceptedOpId = body.operationId;
-                    void waitForOperation(acceptedOpId, 30 * 60_000).then((finalOp) => {
+                    void waitForOperation(acceptedOpId, 30 * 60_000, requestWorkspaceId).then((finalOp) => {
                         if (!finalOp)
                             return;
                         setLastOpState(finalOp.state ?? null);
@@ -118,11 +131,15 @@ export function useOperatorActions(params) {
                                 command: "succeeded",
                             }));
                         }
+                        if (action === "consoleUpdateAndInit" && finalOp.state === "restarting") {
+                            setOpMessage("新 Console 正在接棒，页面即将刷新…");
+                            setTimeout(() => window.location.reload(), 800);
+                        }
                     });
                 }
                 else {
                     setOpMessage(`操作已接受：${body.operationId}`);
-                    const finalOp = await waitForOperation(body.operationId);
+                    const finalOp = await waitForOperation(body.operationId, 300_000, requestWorkspaceId);
                     if (finalOp) {
                         setLastOpState(finalOp.state ?? null);
                         if (finalOp.state === "failed" ||
@@ -222,6 +239,7 @@ export function useOperatorActions(params) {
         setNav,
         setLastOpState,
         setLayers,
+        workspaceId,
     ]);
     const summarizeEnvelope = useCallback((body) => {
         if (!body)
@@ -260,7 +278,10 @@ export function useOperatorActions(params) {
         sseAbort.current = ac;
         setSseLog((prev) => [...prev, `开始跟随事件流 ${opId}`]);
         try {
-            const res = await fetch(`/api/operator/v1/operations/${encodeURIComponent(opId)}/events`, { credentials: "same-origin", signal: ac.signal });
+            const query = operationWorkspaceId
+                ? `?workspaceId=${encodeURIComponent(operationWorkspaceId)}`
+                : "";
+            const res = await fetch(`/api/operator/v1/operations/${encodeURIComponent(opId)}/events${query}`, { credentials: "same-origin", signal: ac.signal });
             if (!res.ok || !res.body) {
                 setSseLog((prev) => [...prev, `事件流 HTTP ${res.status}`]);
                 return;
@@ -294,7 +315,7 @@ export function useOperatorActions(params) {
                 ]);
             }
         }
-    }, [followSse]);
+    }, [followSse, operationWorkspaceId]);
     useEffect(() => {
         if (operationId && followSse && (step === "run" || nav === "recovery")) {
             void followOperationEvents(operationId);
@@ -306,6 +327,19 @@ export function useOperatorActions(params) {
         sseAbort.current?.abort();
         setOpMessage("已停止跟随日志（未取消子进程）");
     }, [setOpMessage]);
+    /** AC-004 (2026-08-26): Operate workspace-switch reset. Aborts the old
+     *  workspace's operation SSE follow and clears operationId + human-gate
+     *  confirmation state. The wizard/recovery ids are cleared by App; this
+     *  hook owns only its own operation/confirmation projection. */
+    const resetForWorkspaceScope = useCallback(() => {
+        sseAbort.current?.abort();
+        setOperationId(null);
+        setOperationWorkspaceId(null);
+        setSseLog([]);
+        setFollowSse(true);
+        setConfirmationId(null);
+        setConfirmationDetails(null);
+    }, []);
     return {
         runAction,
         summarizeEnvelope,
@@ -316,6 +350,7 @@ export function useOperatorActions(params) {
         followSse,
         setFollowSse,
         stopFollowSse,
+        resetForWorkspaceScope,
         confirmationId,
         setConfirmationId,
         confirmationDetails,

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) {
@@ -219,6 +220,22 @@ export function useRecoveryConsole(params) {
             setInterruptEligibility(null);
             return;
         }
+        // Interrupt eligibility only changes while a run is live. Polling a
+        // terminal run every 4s is pure noise — back off to a slow keepalive
+        // (the status itself can still flip if reconciliation rewrites it).
+        const idleStatuses = new Set([
+            "finished",
+            "failed",
+            "partial_failed",
+            "superseded",
+            "abandoned",
+            "interrupted",
+        ]);
+        const intervalMs = recoveryRunStatus && idleStatuses.has(recoveryRunStatus) ? 30_000 : 4_000;
+        // While live (4s cadence) also refresh the run status itself: the
+        // status is only read once per selection, so a run that settles while
+        // selected used to keep the fast eligibility poll forever (2026-08-23).
+        const refreshRunStatus = intervalMs === 4_000;
         let cancelled = false;
         const load = async () => {
             const { body } = await postOperator("dagInterruptEligibility", { runId });
@@ -234,14 +251,32 @@ export function useRecoveryConsole(params) {
                 targetOperationId: result.targetOperationId,
                 targetOperationState: result.targetOperationState,
             });
+            if (!refreshRunStatus)
+                return;
+            try {
+                const res = await fetch(scopedReadUrl(`/api/dag-runs/${encodeURIComponent(runId)}`), { credentials: "same-origin" });
+                if (!res.ok || cancelled)
+                    return;
+                const runBody = (await res.json());
+                if (cancelled)
+                    return;
+                const next = (typeof runBody.effectiveStatus === "string" &&
+                    runBody.effectiveStatus) ||
+                    (typeof runBody.status === "string" && runBody.status) ||
+                    null;
+                setRecoveryRunStatus(next);
+            }
+            catch {
+                // Keep the last known status; the next round retries.
+            }
         };
         void load();
-        const timer = window.setInterval(() => void load(), 4000);
+        const timer = window.setInterval(() => void load(), intervalMs);
         return () => {
             cancelled = true;
             window.clearInterval(timer);
         };
-    }, [nav, dagRunId]);
+    }, [nav, dagRunId, recoveryRunStatus]);
     useEffect(() => {
         if (nav !== "recovery")
             return;

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

@@ -0,0 +1,47 @@
+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;
+/**
+ * Live run progress for the wizard RunPanel. Polls the DAG run detail
+ * endpoint every 5s while the run is live and stops once terminal; returns
+ * null until the first payload arrives. Errors keep the last known state.
+ */
+export function useRunProgress(dagRunId) {
+    const [dag, setDag] = useState(null);
+    useEffect(() => {
+        const runId = dagRunId.trim();
+        setDag(null);
+        if (!runId)
+            return;
+        const controller = new AbortController();
+        let timer;
+        const load = async () => {
+            try {
+                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());
+                if (controller.signal.aborted)
+                    return;
+                setDag(body);
+                if (isTerminalDagRun(body) && timer !== undefined) {
+                    window.clearInterval(timer);
+                    timer = undefined;
+                }
+            }
+            catch {
+                // Keep the last known state; transient failures surface via staleness.
+            }
+        };
+        void load();
+        timer = window.setInterval(() => void load(), RUN_PROGRESS_POLL_INTERVAL_MS);
+        return () => {
+            controller.abort();
+            if (timer !== undefined)
+                window.clearInterval(timer);
+        };
+    }, [dagRunId]);
+    return useMemo(() => summarizeRunProgress(dag), [dag]);
+}

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

@@ -1,6 +1,14 @@
 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(scopedReadUrl(`/api/tasks/${encodeURIComponent(taskId)}/ledger`), { credentials: "same-origin" });
+    if (!response.ok)
+        return { ok: false };
+    const summary = (await response.json());
+    return { ok: true, summary };
+}
 /** Happy Path task wizard: import-prd → interview → contract → dag-confirm →
  *  run. Owns task identity, interview projection and contract preflight/apply. */
 export function useTaskWizard(params) {
@@ -24,16 +32,27 @@ export function useTaskWizard(params) {
     const [contractDiffSummary, setContractDiffSummary] = useState(null);
     const [contractApplied, setContractApplied] = useState(false);
     const [spineOk, setSpineOk] = useState(null);
+    const [ledgerLoading, setLedgerLoading] = useState(false);
+    const [ledgerError, setLedgerError] = useState(null);
+    const [ledgerSummary, setLedgerSummary] = useState(null);
     const [contractPreflightKey, setContractPreflightKey] = useState(null);
     const contractPreflightRunning = useRef(false);
+    /** Epoch guard for ledger fetches: only the newest request may write wizard
+     *  state, so a concurrent in-flight preflight response can never overwrite
+     *  a fresh post-apply result (AC-001). */
+    const ledgerFetchEpoch = useRef(0);
     const resetContractLanding = useCallback(() => {
         setContractValidateOk(null);
         setContractValidateSummary(null);
         setContractDiffSummary(null);
         setContractApplied(false);
         setSpineOk(null);
+        setLedgerLoading(false);
+        setLedgerError(null);
+        setLedgerSummary(null);
         setContractPreflightKey(null);
         contractPreflightRunning.current = false;
+        ledgerFetchEpoch.current = 0;
     }, []);
     const enterContractStep = useCallback(() => {
         resetContractLanding();
@@ -56,6 +75,39 @@ export function useTaskWizard(params) {
                 : "访谈已完成：草稿已绑定完整评估结果");
         }
     }, [enterContractStep, setOpMessage]);
+    /** Epoch-guarded shared ledger refresh used by both the contract-step
+     *  preflight and the post-apply re-GET. `failureSemantics` keeps the
+     *  preflight five-state behavior (non-ok → empty state, no error) while the
+     *  post-apply refresh treats a non-ok/network failure as a safe-degrade
+     *  error per AC-001. */
+    const refreshLedgerState = useCallback(async (id, failureSemantics) => {
+        const epoch = ++ledgerFetchEpoch.current;
+        setLedgerLoading(true);
+        setLedgerError(null);
+        try {
+            const outcome = await fetchLedgerSummary(id);
+            if (ledgerFetchEpoch.current !== epoch)
+                return;
+            if (!outcome.ok) {
+                setLedgerSummary(null);
+                if (failureSemantics) {
+                    setLedgerError("ledger 接口不可达（安全降级）");
+                }
+                return;
+            }
+            setLedgerSummary(outcome.summary);
+        }
+        catch {
+            if (ledgerFetchEpoch.current !== epoch)
+                return;
+            setLedgerError("ledger 接口不可达（安全降级）");
+            setLedgerSummary(null);
+        }
+        finally {
+            if (ledgerFetchEpoch.current === epoch)
+                setLedgerLoading(false);
+        }
+    }, []);
     const runContractPreflight = useCallback(async (force = false) => {
         const id = taskId.trim();
         if (!id)
@@ -74,6 +126,9 @@ export function useTaskWizard(params) {
         setContractDiffSummary(null);
         setSpineOk(null);
         setContractApplied(false);
+        // Shared epoch-guarded refresh preserves the five-state semantics:
+        // non-ok → empty state, network failure → safe-degrade error.
+        await refreshLedgerState(id, false);
         try {
             const validateBody = await runAction("contractValidate", {
                 taskId: id,
@@ -101,6 +156,7 @@ export function useTaskWizard(params) {
         contractPreflightKey,
         contractValidateOk,
         isActionSuccess,
+        refreshLedgerState,
         runAction,
         setOpMessage,
         summarizeEnvelope,
@@ -116,6 +172,11 @@ export function useTaskWizard(params) {
             return;
         }
         setContractApplied(true);
+        // AC-001: re-GET the read-only ledger right after apply succeeds and
+        // write the latest summary BEFORE spineCheck/setStep, so the first
+        // dag-confirm frame shows post-apply statistics (never a loading/empty
+        // flash); refresh failure safe-degrades via ledgerError.
+        await refreshLedgerState(id, true);
         const spineBody = await runAction("spineCheck", { taskId: id });
         if (isActionSuccess(spineBody)) {
             setSpineOk(true);
@@ -125,7 +186,15 @@ export function useTaskWizard(params) {
         }
         setSpineOk(false);
         setOpMessage("契约已应用，但 Spine 审计未通过：可重试 Spine");
-    }, [assessmentId, isActionSuccess, runAction, setOpMessage, setStep, taskId]);
+    }, [
+        assessmentId,
+        isActionSuccess,
+        refreshLedgerState,
+        runAction,
+        setOpMessage,
+        setStep,
+        taskId,
+    ]);
     const retrySpineOnly = useCallback(async () => {
         const id = taskId.trim();
         if (!id)
@@ -282,6 +351,9 @@ export function useTaskWizard(params) {
         contractValidateOk,
         contractValidateSummary,
         contractDiffSummary,
+        ledgerLoading,
+        ledgerError,
+        ledgerSummary,
         contractApplied,
         spineOk,
         applyInterviewPayload,

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/cards/failure-category-advice.js

@@ -0,0 +1,25 @@
+/**
+ * Operator-facing recovery advice per normalized DAG failure category
+ * (mirrors DAG_NORMALIZED_FAILURE_CATEGORIES). The task journey card used to
+ * stop at "原因分类为 X" without telling the operator what to do next; this
+ * maps each class to the concrete next move, aligned with the Recovery
+ * workspace CTAs (node rerun / reconcile / models page).
+ */
+const FAILURE_CATEGORY_ADVICE = {
+    validation: "节点输出未通过契约或门禁校验。可在恢复页从失败节点重跑；若错误指向任务契约（如验证命令、Mock 策略），先修正任务配置并重新生成 DAG。",
+    executor: "执行器或模型提供方调用失败（网络、配额或运行时错误）。稍后可在恢复页从失败节点重跑；反复出现请到「模型与认证」页检查配置与凭据。",
+    "write-guard": "写入越过了授权边界（writeSet / allowedPaths）。检查计划中的写入路径是否越界，修正后从失败节点重跑。",
+    timeout: "节点执行超时。可在恢复页从失败节点重跑；反复超时建议缩小任务范围或排查卡住的命令。",
+    auth: "模型或服务认证失败。请先到「模型与认证」页检查 API Key 与模型配置，再从失败节点重跑。",
+    "human-required": "节点正在等待人工审批。完成审批后该节点可继续执行；也可在恢复页查看对账状态。",
+    "human-rejected": "人工审批被拒绝。请调整任务描述或契约后重新发起任务。",
+    "shell-command": "验证/构建命令以非零退出。进入 DAG 查看命令输出定位具体失败，修复后从失败节点重跑。",
+    "static-error": "静态检查（typecheck / lint 等）失败。修复对应代码错误后从失败节点重跑。",
+    "decision-envelope": "决策与证据不匹配（决策包络校验失败）。进入 DAG 查看节点决策依据，修正后重跑。",
+    unknown: "失败原因未归类。进入 DAG 查看节点详情，或在恢复页使用对账 / 诊断入口。",
+};
+export function failureCategoryAdvice(category) {
+    if (!category)
+        return undefined;
+    return FAILURE_CATEGORY_ADVICE[category];
+}