npm - @tea-agent/loop-agent - Versions diffs - 0.36.0 → 0.36.1 - Mend

@tea-agent/loop-agent 0.36.0 → 0.36.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

package/CHANGELOG.md +11 -0
package/dist/build-stamp.json +3 -3
package/dist/cli/command-definitions.js +7 -0
package/dist/cli/program.js +6 -1
package/dist/commands/dag-request-interrupt.js +20 -0
package/dist/executors/pi-sdk-executor.js +34 -0
package/dist/shared/operator/capabilities.js +76 -3
package/dist/task/source-prepare/semantic-intake.js +144 -23
package/dist/worker/console/chat/semantic-activity.js +6 -0
package/dist/worker/console/chat/workspace-landing.js +1 -0
package/dist/worker/console/operation-runner.js +48 -0
package/dist/worker/console/operation-wait.js +41 -0
package/dist/worker/console/operator-actions.js +235 -26
package/dist/worker/console/operator-user-error.js +4 -0
package/dist/worker/console/recovery-cta.js +50 -3
package/dist/worker/console/recovery-error-copy.js +198 -0
package/dist/worker/console/static/assets/index-D83DYAFG.css +1 -0
package/dist/worker/console/static/assets/index-IXm7oYjL.js +59 -0
package/dist/worker/console/static/index.html +2 -2
package/dist/worker/console/static-src/app/console-types.js +13 -9
package/dist/worker/console/static-src/app/useOperatorActions.js +4 -2
package/dist/worker/console/static-src/app/useRecoveryActions.js +65 -56
package/dist/worker/console/static-src/app/useRecoveryConsole.js +68 -1
package/dist/worker/observability/interrupt-eligibility.js +264 -0
package/dist/worker/observe/static/operator-chrome.d.ts +1 -0
package/dist/worker/observe/static/operator-chrome.js +5 -0
package/dist/worker/observe/static/views/dag.js +12 -0
package/dist/workflows/dag/interrupt-request.js +559 -0
package/dist/workflows/dag/runner.js +72 -4
package/package.json +1 -1
package/skills/loop-agent/references/command-reference.md +1 -0
package/dist/worker/console/static/assets/index-2OeZODxk.js +0 -57
package/dist/worker/console/static/assets/index-DVJlUL8X.css +0 -1

package/dist/worker/console/static/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <link rel="stylesheet" href="/inspect/operator-chrome.css" />
     <title>Loop 操作台 · Operator Console</title>
-    <script type="module" crossorigin src="/assets/index-2OeZODxk.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DVJlUL8X.css">
+    <script type="module" crossorigin src="/assets/index-IXm7oYjL.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D83DYAFG.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/worker/console/static-src/app/console-types.js CHANGED Viewed

@@ -1,3 +1,4 @@
+import { formatIneligibleRerunMessage, nextActionForIneligibleRerun, } from "../../recovery-error-copy.js";
 /** Legacy step ids from older sessions map onto the merged contract step. */
 export function normalizeWizardStep(step) {
     if (step === "validate" || step === "apply" || step === "spine") {
@@ -57,6 +58,7 @@ export const RECOVERY_FACT_LABEL = {
     "terminal-failed": "已终止（失败）",
     "terminal-succeeded": "已终止（成功）",
     "needs-reconcile": "需要对账",
+    "running-active": "正在运行",
 };
 export const LAYER_VALUE_LABEL = {
     idle: "空闲",
@@ -108,18 +110,20 @@ export const LONG_RUNNING_ACTIONS = new Set([
     "runDag",
     "dagRerun",
     "dagReconcileRun",
+    "dagRequestInterrupt",
     "standaloneTaskRerun",
 ]);
-export function formatDagRerunIneligible(plan) {
-    const fromBlocked = (plan.blockedReasons ?? []).map(String);
-    const fromNodes = (plan.blockingNodes ?? []).map((n) => [n.nodeId, n.reasonCode].filter(Boolean).join(":"));
-    const reasons = [...fromBlocked, ...fromNodes].filter(Boolean);
-    if (reasons.length === 0) {
-        return "从节点重跑不具备安全资格（子图含 writer / unsafe shell / decision-gate 等）。可改用「完整重跑任务」，或另选只读安全子图的起始节点。";
-    }
-    return `从节点重跑不具备安全资格：${reasons.slice(0, 6).join("; ")}${reasons.length > 6 ? "…" : ""}。可改用「完整重跑任务」。`;
+export function suggestedRecoveryAfterIneligibleRerun(reasons) {
+    return nextActionForIneligibleRerun(reasons);
+}
+export function formatDagRerunIneligible(plan, fallbackMessage) {
+    return formatIneligibleRerunMessage({
+        blockedReasons: plan.blockedReasons,
+        blockingNodes: plan.blockingNodes,
+        fallbackMessage,
+    });
 }
-export async function waitForOperation(operationId, timeoutMs = 90_000) {
+export async function waitForOperation(operationId, timeoutMs = 300_000) {
     const started = Date.now();
     while (Date.now() - started < timeoutMs) {
         const res = await fetch(`/api/operator/v1/operations/${encodeURIComponent(operationId)}`, { credentials: "same-origin" });

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

@@ -6,8 +6,8 @@ import { confirmationToken, CONFIRMATION_HEADER, LONG_RUNNING_ACTIONS, postOpera
  *  seconds server-side (imports + intake). Prevents the "page looks frozen"
  *  gap between click and the terminal flash message. */
 const ACTION_PROGRESS_COPY = {
-    bootstrapFromPrd: "正在导入 PRD 并创建任务：归档文档 → 确定性解析 → 语义结构化（约 10–60 秒，请勿关闭页面）",
-    importPrd: "正在导入 PRD：归档文档 → 确定性解析 → 语义结构化（约 10–60 秒，请勿关闭页面）",
+    bootstrapFromPrd: "正在导入 PRD 并创建任务：归档文档 → 确定性解析 → 语义结构化（MED→HIGH→LOW，每档最多 300 秒，请勿关闭页面）",
+    importPrd: "正在导入 PRD：归档文档 → 确定性解析 → 语义结构化（MED→HIGH→LOW，每档最多 300 秒，请勿关闭页面）",
     interviewStart: "正在启动需求访谈…",
     interviewTurn: "正在提交访谈回答…",
     interviewSkip: "正在跳过访谈并生成评估…",
@@ -16,6 +16,8 @@ const ACTION_PROGRESS_COPY = {
     contractApply: "正在应用契约（写入需求与执行约束）…",
     spineCheck: "正在运行 Spine 审计…",
     dagGenerate: "正在生成 DAG…",
+    standaloneTaskRerun: "正在完整重跑任务：服务端校验资格后启动新 run…",
+    workerTaskRetry: "正在重新排队 Worker Task…",
 };
 /** Central operator-action dispatcher: POST /api/operator/v1/operations with
  *  polling, long-running background waits, interview payload handoff and the

package/dist/worker/console/static-src/app/useRecoveryActions.js CHANGED Viewed

@@ -1,10 +1,35 @@
 import { useCallback } from "react";
 import { isAutoRecoveryReason } from "../../recovery-selection.js";
+import { formatOperatorUserError } from "../../operator-user-error.js";
 import { formatDagRerunIneligible, postOperator, requestId, } from "./console-types.js";
+/** Destructive reconcile still consumes a browser Human Gate receipt.
+ *  Same-task rerun / Worker retry are autonomous and must not enter here. */
+async function consumeMutationGateAndRun(input) {
+    const prep = await input.runAction("prepareMutationGate", {
+        action: input.action,
+        actionParams: input.actionParams,
+    });
+    if (!input.isActionSuccess(prep))
+        return;
+    const receiptSource = (prep?.result ?? prep);
+    const receipt = receiptSource.receiptId
+        ? receiptSource
+        : (receiptSource.result ?? receiptSource);
+    if (!receipt.receiptId || !receipt.humanGateToken) {
+        input.setOpError("prepareMutationGate 未返回可消费的 Human Gate receipt");
+        return;
+    }
+    await input.runAction(input.action, {
+        ...input.actionParams,
+        confirmationId: receipt.receiptId,
+        humanGateToken: receipt.humanGateToken,
+    }, { clientRequestId: input.clientRequestId });
+}
 /** Recovery CTA dispatch: diagnose/report/inspect shortcuts, reason-gated
- *  confirm flow with dagRerunPlan preflight, and gated reruns/retries. */
+ *  confirm flow with dagRerunPlan preflight, autonomous rerun/retry, and
+ *  Human Gate only for destructive reconcile. */
 export function useRecoveryActions(params) {
-    const { shell, actions, taskId, dagRunId, fromNodeId, featureId, recoveryReason, recoveryReasonTouched, recoveryConfirm, recoveryPlanSummary, setRecoveryConfirm, setRecoveryPlanSummary, setRecoveryReport, setRecoveryReason, setRecoveryReasonTouched, buildCurrentRecoveryReason, openFullCanvas, } = params;
+    const { shell, actions, taskId, dagRunId, fromNodeId, featureId, recoveryReason, recoveryReasonTouched, recoveryConfirm, recoveryPlanSummary, interruptReasonCode, setRecoveryConfirm, setRecoveryPlanSummary, setRecoveryReport, setRecoveryReason, setRecoveryReasonTouched, buildCurrentRecoveryReason, openFullCanvas, } = params;
     const { setOpError, setOpErrorCode, setOpMessage, setBusy } = shell;
     const { runAction, isActionSuccess } = actions;
     const handleRecoveryCta = useCallback(async (cta) => {
@@ -83,7 +108,7 @@ export function useRecoveryActions(params) {
                         setOpMessage(null);
                     }
                     else if (plan.eligible === false) {
-                        setOpError(body.error?.message ?? formatDagRerunIneligible(plan));
+                        setOpError(formatOperatorUserError(formatDagRerunIneligible(plan, body.error?.message)));
                     }
                     else {
                         setOpMessage(body.error?.message ??
@@ -150,7 +175,7 @@ export function useRecoveryActions(params) {
                 planHash = plan.planHash?.trim() || planHash;
                 planEligible = plan.eligible;
                 if (plan.eligible === false) {
-                    setOpError(planBody?.error?.message ?? formatDagRerunIneligible(plan));
+                    setOpError(formatOperatorUserError(formatDagRerunIneligible(plan, planBody?.error?.message)));
                     return;
                 }
                 if (planBody && planBody.ok === false && !planHash) {
@@ -160,7 +185,7 @@ export function useRecoveryActions(params) {
                 }
             }
             if (planEligible === false) {
-                setOpError(formatDagRerunIneligible(recoveryPlanSummary ?? {}));
+                setOpError(formatOperatorUserError(formatDagRerunIneligible(recoveryPlanSummary ?? {})));
                 return;
             }
             if (!planHash) {
@@ -176,26 +201,10 @@ export function useRecoveryActions(params) {
                 setOpError("完整重跑任务需要 DAG 运行 ID");
                 return;
             }
-            const actionParams = {
+            await runAction("standaloneTaskRerun", {
                 runId,
                 reason,
                 ...(taskId.trim() ? { taskId: taskId.trim() } : {}),
-            };
-            const prep = await runAction("prepareMutationGate", {
-                action: "standaloneTaskRerun",
-                actionParams,
-            });
-            if (!isActionSuccess(prep))
-                return;
-            const receipt = (prep?.result ?? prep);
-            if (!receipt.receiptId || !receipt.humanGateToken) {
-                setOpError("prepareMutationGate 未返回可消费的 Human Gate receipt");
-                return;
-            }
-            await runAction("standaloneTaskRerun", {
-                ...actionParams,
-                confirmationId: receipt.receiptId,
-                humanGateToken: receipt.humanGateToken,
             }, { clientRequestId });
             return;
         }
@@ -205,27 +214,35 @@ export function useRecoveryActions(params) {
                 setOpError("重新排队 Worker Task 需要任务 ID");
                 return;
             }
-            const actionParams = {
+            await runAction("workerTaskRetry", {
                 taskId: id,
                 reason,
                 ...(featureId.trim() ? { featureId: featureId.trim() } : {}),
-            };
-            const prep = await runAction("prepareMutationGate", {
-                action: "workerTaskRetry",
-                actionParams,
-            });
-            if (!isActionSuccess(prep))
+            }, { clientRequestId });
+            return;
+        }
+        if (cta.id === "interrupt") {
+            const runId = dagRunId.trim();
+            if (!runId) {
+                setOpError("中止运行需要 DAG 运行 ID");
                 return;
-            const receipt = (prep?.result ?? prep);
-            if (!receipt.receiptId || !receipt.humanGateToken) {
-                setOpError("prepareMutationGate 未返回可消费的 Human Gate receipt");
+            }
+            if (reason.trim().length < 10 || reason.trim().length > 500) {
+                setOpError("中止原因去首尾空白后必须是 10–500 个字符，请手写说明，不要用占位句。");
                 return;
             }
-            await runAction("workerTaskRetry", {
-                ...actionParams,
-                confirmationId: receipt.receiptId,
-                humanGateToken: receipt.humanGateToken,
-            }, { clientRequestId });
+            await consumeMutationGateAndRun({
+                runAction,
+                isActionSuccess,
+                setOpError,
+                action: "dagRequestInterrupt",
+                actionParams: {
+                    runId,
+                    reasonCode: interruptReasonCode.trim() || "operator-request",
+                    reasonDetail: reason,
+                },
+                clientRequestId,
+            });
             return;
         }
         if (cta.id === "reconcile") {
@@ -237,27 +254,18 @@ export function useRecoveryActions(params) {
             // Default supersede: orphan/interrupted runs should not be resumed.
             // The browser Human Gate binds the destructive action + reason; the CLI
             // still fail-closes when runner is not proven dead/stopped.
-            const actionParams = {
-                runId,
-                reason,
-                reconcileAction: "supersede",
-            };
-            const prep = await runAction("prepareMutationGate", {
+            await consumeMutationGateAndRun({
+                runAction,
+                isActionSuccess,
+                setOpError,
                 action: "dagReconcileRun",
-                actionParams,
+                actionParams: {
+                    runId,
+                    reason,
+                    reconcileAction: "supersede",
+                },
+                clientRequestId,
             });
-            if (!isActionSuccess(prep))
-                return;
-            const receipt = (prep?.result ?? prep);
-            if (!receipt.receiptId || !receipt.humanGateToken) {
-                setOpError("prepareMutationGate 未返回可消费的 Human Gate receipt");
-                return;
-            }
-            await runAction("dagReconcileRun", {
-                ...actionParams,
-                confirmationId: receipt.receiptId,
-                humanGateToken: receipt.humanGateToken,
-            }, { clientRequestId });
             return;
         }
         setOpMessage(`${cta.label}：请经 CLI — ${cta.commandHint ?? ""}`);
@@ -268,6 +276,7 @@ export function useRecoveryActions(params) {
         recoveryConfirm,
         recoveryPlanSummary?.planHash,
         recoveryReason,
+        interruptReasonCode,
         runAction,
         isActionSuccess,
         setOpError,

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

@@ -16,6 +16,9 @@ export function useRecoveryConsole(params) {
     const [recoveryReasonTouched, setRecoveryReasonTouched] = useState(false);
     const [recoveryPlanSummary, setRecoveryPlanSummary] = useState(null);
     const [recoveryConfirm, setRecoveryConfirm] = useState(null);
+    const [interruptIntent, setInterruptIntent] = useState(false);
+    const [interruptReasonCode, setInterruptReasonCode] = useState("operator-request");
+    const [interruptEligibility, setInterruptEligibility] = useState(null);
     const [recoveryRuns, setRecoveryRuns] = useState([]);
     const [recoveryNodes, setRecoveryNodes] = useState([]);
     const [recoveryRunsLoading, setRecoveryRunsLoading] = useState(false);
@@ -208,6 +211,37 @@ export function useRecoveryConsole(params) {
             return;
         void loadRecoveryNodes(dagRunId);
     }, [nav, dagRunId, loadRecoveryNodes]);
+    useEffect(() => {
+        if (nav !== "recovery")
+            return;
+        const runId = dagRunId.trim();
+        if (!runId) {
+            setInterruptEligibility(null);
+            return;
+        }
+        let cancelled = false;
+        const load = async () => {
+            const { body } = await postOperator("dagInterruptEligibility", { runId });
+            if (cancelled)
+                return;
+            const result = (body.result ?? body);
+            setInterruptEligibility({
+                eligible: result.eligible === true,
+                ownerKind: result.ownerKind,
+                message: result.message,
+                interruptStatus: result.interruptStatus,
+                reasonCodes: result.reasonCodes,
+                targetOperationId: result.targetOperationId,
+                targetOperationState: result.targetOperationState,
+            });
+        };
+        void load();
+        const timer = window.setInterval(() => void load(), 4000);
+        return () => {
+            cancelled = true;
+            window.clearInterval(timer);
+        };
+    }, [nav, dagRunId]);
     useEffect(() => {
         if (nav !== "recovery")
             return;
@@ -233,7 +267,14 @@ export function useRecoveryConsole(params) {
         dagStatus: recoveryRunStatus,
         failureCategory: recoveryFailureCategory,
     });
-    const recoveryCtas = useMemo(() => consoleRecoveryCtas(recoveryFact), [recoveryFact]);
+    const recoveryCtas = useMemo(() => {
+        const ctas = consoleRecoveryCtas(recoveryFact);
+        if (recoveryFact !== "running-active")
+            return ctas;
+        if (interruptEligibility?.eligible)
+            return ctas;
+        return ctas.filter((cta) => cta.id !== "interrupt");
+    }, [recoveryFact, interruptEligibility?.eligible]);
     const recoveryLanes = useMemo(() => partitionRecoveryCtas(recoveryCtas), [recoveryCtas]);
     const recommendedCtaId = useMemo(() => recommendedRecoveryCtaId(recoveryFact), [recoveryFact]);
     const selectedRecoveryNode = useMemo(() => recoveryNodes.find((n) => n.nodeId === fromNodeId.trim()), [recoveryNodes, fromNodeId]);
@@ -299,6 +340,7 @@ export function useRecoveryConsole(params) {
         recoveryReasonTouched,
         recoveryConfirm,
         recoveryPlanSummary,
+        interruptReasonCode,
         setRecoveryConfirm,
         setRecoveryPlanSummary,
         setRecoveryReport,
@@ -307,6 +349,25 @@ export function useRecoveryConsole(params) {
         buildCurrentRecoveryReason,
         openFullCanvas,
     });
+    useEffect(() => {
+        if (nav !== "recovery" || !interruptIntent)
+            return;
+        if (!interruptEligibility?.eligible)
+            return;
+        const interruptCta = recoveryCtas.find((cta) => cta.id === "interrupt");
+        if (!interruptCta)
+            return;
+        setRecoveryConfirm(interruptCta);
+        setRecoveryReason(buildCurrentRecoveryReason(interruptCta.label));
+        setRecoveryReasonTouched(false);
+        setInterruptIntent(false);
+    }, [
+        nav,
+        interruptIntent,
+        interruptEligibility?.eligible,
+        recoveryCtas,
+        buildCurrentRecoveryReason,
+    ]);
     return {
         dagRunId,
         setDagRunId,
@@ -327,6 +388,7 @@ export function useRecoveryConsole(params) {
         recoveryRunsLoading,
         recoveryNodesLoading,
         recoveryRunStatus,
+        recoveryFailureCategory,
         frontendRecovery,
         manualRunId,
         setManualRunId,
@@ -350,6 +412,11 @@ export function useRecoveryConsole(params) {
         recoveryCtas,
         recoveryLanes,
         recommendedCtaId,
+        interruptIntent,
+        setInterruptIntent,
+        interruptReasonCode,
+        setInterruptReasonCode,
+        interruptEligibility,
         recoveryConfirmRef,
         buildCurrentRecoveryReason,
         handleRecoveryCta,

package/dist/worker/observability/interrupt-eligibility.js ADDED Viewed

@@ -0,0 +1,264 @@
+import { hostname as localHostname } from "node:os";
+import { DagInterruptError, INTERRUPT_ERROR_MESSAGES, projectedInterruptStatus, readInterruptRequest, runnerIdentitiesMatch, runnerIdentityFromState, } from "../../workflows/dag/interrupt-request.js";
+import { assessDagRunLiveness, locateDagRun, readDagRunState, } from "../../workflows/dag/lifecycle.js";
+function operationControllerFingerprint(operation) {
+    const identity = operation.controllerIdentity;
+    if (!identity)
+        return undefined;
+    if ("fingerprint" in identity && typeof identity.fingerprint === "string") {
+        const value = identity.fingerprint.trim();
+        return value || undefined;
+    }
+    if ("packageFingerprint" in identity &&
+        identity.packageFingerprint &&
+        typeof identity.packageFingerprint === "object" &&
+        "value" in identity.packageFingerprint &&
+        typeof identity.packageFingerprint.value === "string") {
+        const value = identity.packageFingerprint.value.trim();
+        return value || undefined;
+    }
+    return undefined;
+}
+function ineligible(partial) {
+    const code = partial.reasonCodes[0] ?? "RUN_NOT_ACTIVE";
+    return {
+        ...partial,
+        eligible: false,
+        message: partial.message ?? INTERRUPT_ERROR_MESSAGES[code],
+    };
+}
+function bindLiveOperations(input) {
+    return input.operations.filter((operation) => {
+        if (operation.state !== "running" && operation.state !== "starting") {
+            return false;
+        }
+        if (operation.pid !== input.runner.pid)
+            return false;
+        if (operation.dagRunId && operation.dagRunId !== input.runId)
+            return false;
+        const fingerprint = operationControllerFingerprint(operation);
+        if (!fingerprint || fingerprint !== input.runner.controllerFingerprint) {
+            return false;
+        }
+        return true;
+    });
+}
+export async function evaluateConsoleDagInterruptEligibility(input) {
+    const runId = input.runId.trim();
+    if (!runId) {
+        return ineligible({
+            runId: "",
+            ownerKind: "unknown",
+            reasonCodes: ["INVALID_INPUT"],
+            interruptStatus: "none",
+        });
+    }
+    const located = await locateDagRun(input.repoRoot, runId);
+    if (!located) {
+        return ineligible({
+            runId,
+            ownerKind: "unknown",
+            reasonCodes: ["RUN_NOT_ACTIVE"],
+            interruptStatus: "none",
+        });
+    }
+    let state;
+    try {
+        state = await readDagRunState(located.runDir);
+    }
+    catch {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            ownerKind: "unknown",
+            reasonCodes: ["RUN_NOT_ACTIVE"],
+            interruptStatus: "none",
+        });
+    }
+    let interrupt;
+    try {
+        interrupt = await readInterruptRequest(located.runDir);
+    }
+    catch {
+        interrupt = undefined;
+    }
+    const interruptStatus = projectedInterruptStatus(interrupt);
+    if (state.workerAssociation) {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            ownerKind: "worker-managed",
+            reasonCodes: ["RUN_NOT_CONSOLE_OWNED"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    if (located.lifecycle !== "active" || state.status !== "running") {
+        const terminal = located.lifecycle === "completed" ||
+            located.lifecycle === "paused" ||
+            state.status === "paused" ||
+            state.status === "finished" ||
+            state.status === "failed" ||
+            state.status === "partial_failed" ||
+            state.status === "superseded" ||
+            state.status === "abandoned";
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            ownerKind: "external-local",
+            reasonCodes: [terminal ? "RUN_ALREADY_TERMINAL" : "RUN_NOT_ACTIVE"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    const runner = runnerIdentityFromState(state);
+    if (!runner) {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            ownerKind: "unknown",
+            reasonCodes: ["RUNNER_IDENTITY_MISMATCH"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    if (runner.hostname !== (input.hostname ?? localHostname())) {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            ownerKind: "external-local",
+            reasonCodes: ["RUN_NOT_CONSOLE_OWNED"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    const liveness = assessDagRunLiveness({
+        state,
+        hostname: input.hostname ?? localHostname(),
+    });
+    if (liveness.status === "orphaned" || liveness.status === "unknown-host") {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            ownerKind: "unknown",
+            reasonCodes: ["RUN_NOT_ACTIVE"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    const liveOps = await input.operations.list();
+    const matches = bindLiveOperations({
+        operations: liveOps,
+        runId,
+        runner,
+    });
+    const targetFromInterrupt = interrupt?.targetOperationId
+        ? (liveOps.find((op) => op.operationId === interrupt.targetOperationId) ??
+            (await input.operations.get(interrupt.targetOperationId)))
+        : undefined;
+    const targetOperationState = (matches.length === 1 ? matches[0]?.state : undefined) ??
+        targetFromInterrupt?.state;
+    const expected = {
+        pid: runner.pid,
+        hostname: runner.hostname,
+        startedAt: runner.startedAt,
+        controllerFingerprint: runner.controllerFingerprint,
+    };
+    if (interrupt &&
+        (interrupt.status === "requested" || interrupt.status === "acknowledged")) {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            failureCategory: state.failureCategory,
+            ownerKind: "console-operation",
+            targetOperationId: interrupt.targetOperationId,
+            targetOperationState,
+            expectedRunnerIdentity: runner,
+            reasonCodes: ["INTERRUPT_ALREADY_PENDING"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    if (interrupt?.status === "needs-reconcile") {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            failureCategory: state.failureCategory,
+            ownerKind: "console-operation",
+            targetOperationId: interrupt.targetOperationId,
+            targetOperationState,
+            expectedRunnerIdentity: runner,
+            reasonCodes: ["INTERRUPT_NEEDS_RECONCILE"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    if (matches.length === 0) {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            failureCategory: state.failureCategory,
+            ownerKind: "external-local",
+            reasonCodes: ["RUN_NOT_CONSOLE_OWNED"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    if (matches.length > 1) {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            failureCategory: state.failureCategory,
+            ownerKind: "unknown",
+            reasonCodes: ["RUNNER_IDENTITY_MISMATCH"],
+            message: "找到多个可能持有该运行的 Console operation，无法无歧义绑定。请用 Doctor 查看，不要猜测。",
+            interruptStatus,
+            interrupt,
+        });
+    }
+    const target = matches[0];
+    if (target.pid !== expected.pid ||
+        !runnerIdentitiesMatch(expected, runner)) {
+        return ineligible({
+            runId,
+            lifecycle: located.lifecycle,
+            dagStatus: state.status,
+            failureCategory: state.failureCategory,
+            ownerKind: "unknown",
+            reasonCodes: ["RUNNER_IDENTITY_MISMATCH"],
+            interruptStatus,
+            interrupt,
+        });
+    }
+    return {
+        eligible: true,
+        runId,
+        lifecycle: located.lifecycle,
+        dagStatus: state.status,
+        failureCategory: state.failureCategory,
+        ownerKind: "console-operation",
+        targetOperationId: target.operationId,
+        targetOperationState: target.state,
+        expectedRunnerIdentity: expected,
+        reasonCodes: [],
+        message: "可以由当前 Console 协作中止此运行。",
+        interruptStatus,
+        interrupt,
+    };
+}
+export function interruptEligibilityError(eligibility) {
+    const code = eligibility.reasonCodes[0] ?? "RUN_NOT_ACTIVE";
+    return new DagInterruptError(code, eligibility.message);
+}
+// Console-side re-exports: keep the console layer free of direct workflows/dag
+// kernel imports (see test/worker/console/security-and-tools.test.ts).
+export { INTERRUPT_ERROR_MESSAGES, isInterruptReasonCode, normalizeInterruptReasonDetail, } from "../../workflows/dag/interrupt-request.js";

package/dist/worker/observe/static/operator-chrome.d.ts CHANGED Viewed

@@ -49,6 +49,7 @@ export function parseInspectObjectView(
 export function activeInspectTabHref(hashValue: string): string | null;
 export function parseInspectContext(hashValue: string): InspectContext | null;
 export function resolveOperateHrefFromInspectHash(hashValue: string): string;
+export function buildOperateInterruptHref(dagRunId: string): string;
 export function buildInspectDagHref(
 	dagRunId: string,
 	options?: { from?: string },

package/dist/worker/observe/static/operator-chrome.js CHANGED Viewed

@@ -118,6 +118,11 @@ export function resolveOperateHrefFromInspectHash(hashValue) {
 	return "/#/";
 }
+/** Inspect DAG 详情 → Operate Recovery 协作中止深链（只改导航，不发 mutation）。 */
+export function buildOperateInterruptHref(dagRunId) {
+	return `/#/recovery?dagRunId=${encodeURIComponent(dagRunId)}&intent=interrupt`;
+}
 /** 操作侧 → Inspect 的 canonical 深链（可携带 from 以激活上下文 chip）。 */
 export function buildInspectDagHref(dagRunId, options = {}) {
 	const base = `/inspect/#/dag/${encodeURIComponent(dagRunId)}`;