@tea-agent/loop-agent 0.36.1-beta.0 → 0.36.1

package/dist/worker/console/operator-actions.js

@@ -18,19 +18,23 @@ import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.js";
 import { appendEngineeringCliArgs, buildDraftFromTaskIntake, parseEngineeringBoundaryFromParams, } from "./prd-intake-bridge.js";
 import { discoverPrdReferences } from "./prd-reference-discovery.js";
-import { clearSemanticIntakeAttempt } from "../../task/source-prepare/semantic-intake.js";
+import { clearSemanticIntakeAttempt, SEMANTIC_INTAKE_CLI_TIMEOUT_MS, } from "../../task/source-prepare/semantic-intake.js";
 import nodePath from "node:path";
 import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
 import { projectOperationEventSummary, projectOperationForChat, } from "./chat/chat-event-store.js";
 import { OperationWaitError, waitForOperationChange, } from "./operation-wait.js";
 import { MutationGateReceiptStore } from "./mutation-gate-receipt-store.js";
+import { formatIneligibleRerunMessage } from "./recovery-error-copy.js";
+import { evaluateConsoleDagInterruptEligibility } from "../observability/interrupt-eligibility.js";
+import { INTERRUPT_ERROR_MESSAGES, isInterruptReasonCode, normalizeInterruptReasonDetail, } from "../observability/interrupt-eligibility.js";
 import { assessAutonomousExecutionEligibility, deriveEligibilityFactsFromDagSpec, } from "./dag-execution-receipt.js";
 import { issueHumanGateToken, mutationGatePayloadHash, verifyHumanGateToken, } from "./human-gate-token.js";
 const MUTATION_GATE_ACTIONS = new Set([
     // 2026-08-11: standaloneTaskRerun / workerTaskRetry are autonomous (server
-    // run-facts checks). Destructive DAG reconciliation and Night Scheduler
-    // mutations still need the browser Human Gate.
+    // run-facts checks). Destructive DAG reconciliation, live cooperative
+    // interrupt, and Night Scheduler mutations still need the browser Human Gate.
     "dagReconcileRun",
+    "dagRequestInterrupt",
     "workerAdmissionPrepare",
     "workerSchedulerAdd",
     "workerSchedulerCancel",
@@ -48,6 +52,7 @@ const MUTATION_OR_LONG = new Set([
     "runDag",
     "dagRerun",
     "dagReconcileRun",
+    "dagRequestInterrupt",
     "standaloneTaskRerun",
     "workerTaskRetry",
 ]);
@@ -138,27 +143,46 @@ function gateError(action, code, message, details) {
         }),
     };
 }
+/**
+ * `dag report --json` is `{ schemaVersion, runs: [...] }` (no Operator `ok`).
+ * `runReadCli` used to wrap that as `{ stdout, raw }`, which made the
+ * autonomous rerun gate miss `primaryFailure` even after the UI showed the
+ * report (2026-08-16). Accept both the native report shape and the wrap.
+ */
+function extractDagReportRunFacts(reportResult, runId) {
+    const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+    const result = asRecord(reportResult);
+    const envelope = Array.isArray(result?.runs)
+        ? result
+        : asRecord(result?.raw);
+    if (!envelope)
+        return undefined;
+    const runs = Array.isArray(envelope.runs) ? envelope.runs : [];
+    const matched = runs.find((entry) => asRecord(entry)?.runId === runId) ?? runs[0];
+    const matchedRec = asRecord(matched);
+    if (matchedRec?.primaryFailure) {
+        return {
+            primaryFailure: asRecord(matchedRec.primaryFailure),
+            primaryRecovery: asRecord(matchedRec.primaryRecovery),
+        };
+    }
+    if (envelope.primaryFailure) {
+        return {
+            primaryFailure: asRecord(envelope.primaryFailure),
+            primaryRecovery: asRecord(envelope.primaryRecovery),
+        };
+    }
+    return undefined;
+}
 /**
  * 2026-08-11 R2 run-facts check for standaloneTaskRerun (read-only CLI
  * evidence only — no browser Human Gate). Fails closed when facts are missing.
  */
 async function assertAutonomousRerunEligible(ctx, runId, taskId) {
     const report = await runReadCli(ctx, ["dag", "report", "--run-id", runId, "--json"], "dag report");
-    // `dag report --json` emits { schemaVersion, runs: [...] } — the run facts
-    // (primaryFailure / primaryRecovery) live on each entry of `runs`, not on
-    // the envelope top level. Reading them from the top level made every
-    // standaloneTaskRerun call fail closed with "cannot read dagReport run
-    // facts" even though the evidence was present (2026-08-15 parse drift).
-    const reportEnvelope = (report.ok ? report.result : undefined);
-    const reportRuns = reportEnvelope?.runs ?? [];
-    const matchedRun = reportRuns.find((entry) => entry.runId === runId) ?? reportRuns[0];
-    const reportResult = matchedRun ??
-        (reportEnvelope?.primaryFailure
-            ? {
-                primaryFailure: reportEnvelope.primaryFailure,
-                primaryRecovery: reportEnvelope.primaryRecovery,
-            }
-            : undefined);
+    const reportResult = extractDagReportRunFacts(report.ok ? report.result : undefined, runId);
     const recovery = reportResult?.primaryRecovery;
     if (!report.ok || !reportResult?.primaryFailure || !recovery) {
         return gateError("standaloneTaskRerun", "INVALID_INPUT", "cannot read dagReport run facts; standaloneTaskRerun requires server-side run evidence", { runId });
@@ -304,6 +328,9 @@ async function runReadCli(ctx, args, command) {
             if (env.schemaVersion === 1 && typeof env.ok === "boolean") {
                 return env;
             }
+            if (raw.schemaVersion === 1 && Array.isArray(raw.runs)) {
+                return operatorSucceeded(command, raw);
+            }
             if (command === "dag rerun plan" &&
                 raw.plan &&
                 typeof raw.plan === "object") {
@@ -315,9 +342,8 @@ async function runReadCli(ctx, args, command) {
                     ? plan.blockedReasons.map(String)
                     : [];
                 const blockingNodes = Array.isArray(plan.blockingNodes)
-                    ? plan.blockingNodes.map((n) => [n.nodeId, n.reasonCode].filter(Boolean).join(":"))
+                    ? plan.blockingNodes
                     : [];
-                const reasons = [...blockedReasons, ...blockingNodes].filter(Boolean);
                 return buildOperatorResult({
                     command,
                     ok: false,
@@ -325,9 +351,10 @@ async function runReadCli(ctx, args, command) {
                     result: plan,
                     error: {
                         code: "DAG_RERUN_INELIGIBLE",
-                        message: reasons.length > 0
-                            ? `从节点重跑不具备安全资格：${reasons.slice(0, 6).join("; ")}${reasons.length > 6 ? "…" : ""}`
-                            : "从节点重跑不具备安全资格（eligible=false）",
+                        message: formatIneligibleRerunMessage({
+                            blockedReasons,
+                            blockingNodes,
+                        }),
                         details: {
                             eligible: false,
                             planHash: typeof plan.planHash === "string" ? plan.planHash : undefined,
@@ -564,6 +591,30 @@ export async function dispatchOperatorAction(ctx, req) {
                     afterSeq,
                     maxWaitMs,
                     ...(wakeOn ? { wakeOn } : {}),
+                    poll: async () => {
+                        const current = await ctx.operations.get(operationId);
+                        const runId = current?.dagRunId ??
+                            (typeof current?.actionParams?.runId === "string"
+                                ? current.actionParams.runId
+                                : undefined);
+                        if (!current || !runId)
+                            return false;
+                        const eligibility = await evaluateConsoleDagInterruptEligibility({
+                            repoRoot: ctx.repoRoot,
+                            operations: ctx.operations,
+                            runId,
+                        });
+                        if (!eligibility.interrupt)
+                            return false;
+                        const targetId = eligibility.targetOperationId ?? current.operationId;
+                        return syncTargetInterruptProjection({
+                            operations: ctx.operations,
+                            events: ctx.events,
+                            operationId: targetId,
+                            runId,
+                            interrupt: eligibility.interrupt,
+                        });
+                    },
                 });
                 return {
                     kind: "sync",
@@ -1557,7 +1608,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 cwd: ctx.repoRoot,
                 artifactName: "import-prd-task-advance-intake",
                 expectJson: true,
-                timeoutMs: 300_000,
+                timeoutMs: SEMANTIC_INTAKE_CLI_TIMEOUT_MS,
             });
             const intakeJson = intake.json ?? null;
             const intakeOk = intake.ok && intake.exitCode === 0 && !intake.timedOut;
@@ -1983,6 +2034,99 @@ export async function dispatchOperatorAction(ctx, req) {
                 ],
             });
         }
+        case "dagInterruptEligibility": {
+            const runId = str(p.runId) ?? str(p.dagRunId);
+            if (!runId)
+                return invalid(action, "runId is required");
+            const eligibility = await evaluateConsoleDagInterruptEligibility({
+                repoRoot: ctx.repoRoot,
+                operations: ctx.operations,
+                runId,
+            });
+            if (eligibility.interrupt && eligibility.targetOperationId) {
+                await syncTargetInterruptProjection({
+                    operations: ctx.operations,
+                    events: ctx.events,
+                    operationId: eligibility.targetOperationId,
+                    runId,
+                    interrupt: eligibility.interrupt,
+                });
+            }
+            return {
+                kind: "sync",
+                status: 200,
+                body: operatorSucceeded(action, eligibility),
+            };
+        }
+        case "dagRequestInterrupt": {
+            const runId = str(p.runId);
+            const reasonCode = str(p.reasonCode);
+            const reasonDetail = str(p.reasonDetail) ?? str(p.reason);
+            const clientRequestId = str(req.clientRequestId);
+            if (!runId || !reasonCode || !reasonDetail || !clientRequestId) {
+                return invalid(action, "runId, reasonCode, reasonDetail, and clientRequestId are required");
+            }
+            if (!isInterruptReasonCode(reasonCode)) {
+                return invalid(action, `reasonCode must be one of requirements-changed | suspected-runaway | resource-protection | operator-request | other`);
+            }
+            try {
+                normalizeInterruptReasonDetail(reasonDetail);
+            }
+            catch (error) {
+                return invalid(action, error instanceof Error ? error.message : String(error));
+            }
+            const gated = await consumeMutationGateReceipt(ctx, action, p);
+            if (gated.kind === "error")
+                return gated;
+            if (gated.kind === "idempotent")
+                return gated.result;
+            const eligibility = await evaluateConsoleDagInterruptEligibility({
+                repoRoot: ctx.repoRoot,
+                operations: ctx.operations,
+                runId,
+            });
+            if (!eligibility.eligible || !eligibility.targetOperationId || !eligibility.expectedRunnerIdentity) {
+                const failed = interruptActionFailed(action, eligibility.reasonCodes[0] ?? "RUN_NOT_ACTIVE", eligibility.message);
+                return failed;
+            }
+            const expected = eligibility.expectedRunnerIdentity;
+            const accepted = await acceptOperation(ctx, {
+                action,
+                actionParams: {
+                    runId,
+                    reasonCode,
+                    reasonDetail,
+                    targetOperationId: eligibility.targetOperationId,
+                    expectedRunnerIdentity: expected,
+                },
+                clientRequestId,
+                cliArgs: [
+                    "dag",
+                    "request-interrupt",
+                    "--run-id",
+                    runId,
+                    "--request-id",
+                    clientRequestId,
+                    "--target-operation-id",
+                    eligibility.targetOperationId,
+                    "--reason-code",
+                    reasonCode,
+                    "--reason",
+                    reasonDetail,
+                    "--expected-runner-pid",
+                    String(expected.pid),
+                    "--expected-runner-hostname",
+                    expected.hostname,
+                    "--expected-runner-started-at",
+                    expected.startedAt,
+                    "--expected-controller-fingerprint",
+                    expected.controllerFingerprint,
+                    "--json",
+                ],
+            });
+            await finalizeMutationGateReceipt(ctx, gated.receiptId, accepted);
+            return accepted;
+        }
         case "dagReconcileRun": {
             // S6 Recovery: orphan/interrupted runs — structured reason is the human
             // confirmation surface (CLI eligibility still fail-closed).
@@ -2276,7 +2420,7 @@ export async function dispatchOperatorAction(ctx, req) {
                 return invalid(action, "action and actionParams are required");
             }
             if (!MUTATION_GATE_ACTIONS.has(targetAction)) {
-                return invalid(action, "action must be a mutation-gate target (dagReconcileRun | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard)");
+                return invalid(action, "action must be a mutation-gate target (dagReconcileRun | dagRequestInterrupt | workerAdmissionPrepare | workerSchedulerAdd | workerSchedulerCancel | workerSchedulerHarvest | workerSchedulerDiscard)");
             }
             const secret = ctx.humanGateSecret;
             if (!secret) {
@@ -2847,7 +2991,7 @@ async function dispatchBootstrapFromPrd(ctx, p) {
         cwd: ctx.repoRoot,
         artifactName: "bootstrap-task-advance-intake",
         expectJson: true,
-        timeoutMs: 300_000,
+        timeoutMs: SEMANTIC_INTAKE_CLI_TIMEOUT_MS,
     });
     const intakeJson = intake.json ?? null;
     const intakeOk = intake.ok && intake.exitCode === 0 && !intake.timedOut;
@@ -3321,6 +3465,71 @@ function invalid(action, message) {
         }),
     };
 }
+function interruptActionFailed(action, code, message) {
+    const blocked = code === "INTERRUPT_ALREADY_PENDING" ||
+        code === "INTERRUPT_NEEDS_RECONCILE" ||
+        code === "RUN_ALREADY_TERMINAL" ||
+        code === "RUN_NOT_CONSOLE_OWNED" ||
+        code === "RUNNER_IDENTITY_MISMATCH" ||
+        code === "RUN_NOT_ACTIVE";
+    return {
+        kind: "error",
+        status: code === "INVALID_INPUT" ? 400 : 409,
+        body: operatorFailed({
+            command: action,
+            outcome: blocked ? "blocked" : "invalid",
+            code,
+            message: message || INTERRUPT_ERROR_MESSAGES[code] || message,
+        }),
+    };
+}
+async function syncTargetInterruptProjection(input) {
+    const current = await input.operations.get(input.operationId);
+    if (!current)
+        return false;
+    if (current.interrupt?.status === input.interrupt.status &&
+        current.interrupt?.requestId === input.interrupt.requestId) {
+        return false;
+    }
+    const nextStatus = input.interrupt.status;
+    if (nextStatus !== "requested" &&
+        nextStatus !== "acknowledged" &&
+        nextStatus !== "settled" &&
+        nextStatus !== "needs-reconcile") {
+        return false;
+    }
+    await input.operations.update(input.operationId, {
+        dagRunId: current.dagRunId ?? input.runId,
+        interrupt: {
+            status: nextStatus,
+            ...(input.interrupt.requestId
+                ? { requestId: input.interrupt.requestId }
+                : {}),
+            ...(input.interrupt.reasonCode
+                ? { reasonCode: input.interrupt.reasonCode }
+                : {}),
+            ...(input.interrupt.requestedAt
+                ? { requestedAt: input.interrupt.requestedAt }
+                : {}),
+            ...(input.interrupt.acknowledgedAt
+                ? { acknowledgedAt: input.interrupt.acknowledgedAt }
+                : {}),
+            ...(input.interrupt.settledAt
+                ? { settledAt: input.interrupt.settledAt }
+                : {}),
+            ...(input.interrupt.outcome ? { outcome: input.interrupt.outcome } : {}),
+        },
+    });
+    input.events.append(input.operationId, {
+        kind: "state",
+        message: `interrupt ${nextStatus}`,
+        data: {
+            interruptStatus: nextStatus,
+            runId: input.runId,
+        },
+    });
+    return true;
+}
 function confirmationErrorStatus(code) {
     if (code === "NOT_FOUND")
         return 404;

package/dist/worker/console/operator-user-error.js

@@ -1,8 +1,12 @@
+import { rewriteRecoveryOperatorError } from "./recovery-error-copy.js";
 /** Map internal spawn/controller errors to actionable Chinese copy. */
 export function formatOperatorUserError(message) {
     const raw = (message ?? "").trim();
     if (!raw)
         return "操作失败";
+    const recovery = rewriteRecoveryOperatorError(raw);
+    if (recovery)
+        return recovery;
     if (/controller identity changed|package fingerprint changed|entry binary sha256 changed/i.test(raw)) {
         return "控制器版本已变更（Console 启动后代码被重新编译）。请重启 Console 后再试，一次会话中途不要升级/重建控制器。";
     }

package/dist/worker/console/recovery-cta.js

@@ -63,7 +63,7 @@ const CTA = {
         requiresReason: true,
         action: "dagRerun",
         lane: "dag",
-        guide: "终端失败默认首选：先 dagRerunPlan，plan 合格再 Human Gate 执行；provider 抖动/只读下游优先，勿无理由新开 task",
+        guide: "终端失败默认首选：先 dagRerunPlan，plan 合格后直接执行（无需 Human Gate）。Worker 持有的 run、workspace/controller 漂移或含 unsafe shell 时不要强跑子图",
         commandHint: "loop-agent dag rerun --run-id <run-id> --from-node <node-id> --plan",
     },
     standaloneTaskRerun: {
@@ -72,7 +72,7 @@ const CTA = {
         requiresReason: true,
         action: "standaloneTaskRerun",
         lane: "dag",
-        guide: "整单重跑：仅当 from-node plan 不合格（writer/decision/fingerprint）或契约/源真变时；需确认原因",
+        guide: "独立 DAG run 整单重跑：仅当 from-node plan 不合格时直调执行，服务端校验 run facts，无需 Human Gate。Worker 持有的 run 请用下方「重新排队 Worker Task」",
         commandHint: "loop-agent dag rerun-task --run-id <run-id> --reason <text> --json",
     },
     workerTaskRetry: {
@@ -81,9 +81,18 @@ const CTA = {
         requiresReason: true,
         action: "workerTaskRetry",
         lane: "worker",
-        guide: "仅 Worker 队列任务失败时使用，不要与 DAG 重跑混用",
+        guide: "仅 Worker 队列任务失败时直调执行，服务端校验 Failed 状态，无需 Human Gate；不要与 DAG 完整重跑混用",
         commandHint: "agent-worker task retry <task-id> --feature-id <feature-id> --repo . --reason <reason>",
     },
+    interrupt: {
+        id: "interrupt",
+        label: "中止运行",
+        requiresReason: true,
+        action: "dagRequestInterrupt",
+        lane: "dag",
+        guide: "仅本机 Console 持有的正在运行 DAG：经 Human Gate 登记协作中止，等待当前节点安全收敛。不会立即强杀进程",
+        commandHint: "loop-agent dag request-interrupt --run-id <run-id> --reason-code operator-request --reason <structured-reason>",
+    },
 };
 const MATRIX = {
     "validation-failed": ["report", "doctor", "regenerate"],
@@ -111,6 +120,7 @@ const MATRIX = {
     ],
     "terminal-succeeded": ["report", "observeLink"],
     "needs-reconcile": ["report", "doctor", "reconcile", "regenerate"],
+    "running-active": ["interrupt", "report", "doctor", "observeLink"],
 };
 const FORBIDDEN_LABELS = [
     "直接改代码",
@@ -118,6 +128,38 @@ const FORBIDDEN_LABELS = [
     "Cancel",
     "cancel operation",
 ];
+const TERMINAL_OPERATION_STATES = new Set([
+    "succeeded",
+    "failed",
+    "timed-out",
+]);
+/**
+ * Orthogonal interrupt progress copy. "已中止" only when run terminal facts and
+ * the target operation exit are both confirmed; otherwise keep requested /
+ * converging / reconcile wording.
+ */
+export function interruptProgressCopy(input) {
+    const status = (input.interruptStatus ?? "").trim();
+    if (!status || status === "none")
+        return null;
+    if (status === "requested")
+        return "请求已登记，等待 runner 确认。";
+    if (status === "acknowledged") {
+        return "等待当前节点安全收敛（不会立即强杀）。";
+    }
+    if (status === "needs-reconcile") {
+        return "需要对账：中止请求未能确认。";
+    }
+    if (status === "settled") {
+        const terminalRun = input.dagStatus === "failed" || input.dagStatus === "partial_failed";
+        const interrupted = (input.failureCategory ?? "").includes("controller-interrupted");
+        const operationExited = TERMINAL_OPERATION_STATES.has(input.targetOperationState ?? "");
+        if (terminalRun && interrupted && operationExited)
+            return "已中止。";
+        return "正在对账，尚未确认退出。";
+    }
+    return null;
+}
 /**
  * Return allowed recovery CTAs for a fact/failure class.
  * Never includes Cancel or primary "edit code".
@@ -173,6 +215,8 @@ export function recommendedRecoveryCtaId(factClass) {
         case "needs-reconcile":
             // Prefer doctor first; reconcile is available when operator confirms reason.
             return pick("doctor", "reconcile", "report");
+        case "running-active":
+            return pick("interrupt", "doctor", "report");
         case "runtime-mismatch":
         case "contract-drift":
             return pick("doctor", "report");
@@ -251,6 +295,9 @@ export function classifyRecoveryFact(input) {
         state.includes("suspected-stall")) {
         return "orphan-unknown";
     }
+    if (dag === "running" || dag === "active") {
+        return "running-active";
+    }
     if (state === "succeeded" ||
         state === "completed" ||
         state === "finished" ||

package/dist/worker/console/recovery-error-copy.js

@@ -0,0 +1,198 @@
+/**
+ * Operator-facing Chinese copy for recovery failures.
+ * Reason codes stay in plan JSON; flash / chat must not dump them raw.
+ */
+const REASON_LABELS = {
+    "worker-managed-rerun-unsupported": "这次运行由 Console/Worker 启动，不能只从某个节点续跑",
+    "workspace-drift": "工作区在上次运行后又改过文件，旧结果不能接着用",
+    "controller-drift": "控制器版本已变化，不能接到上次运行上继续",
+    "binding-drift": "任务契约或源文件已变化，不能只续跑旧计划",
+    "restart-subgraph-contains-unsafe-shell": "下游包含会执行命令的验证步骤，不能只重跑这一段",
+    "restart-subgraph-contains-writer": "下游包含会改代码的写入步骤，不能只重跑这一段",
+    "restart-subgraph-contains-decision-gate": "下游包含需要人工决策的门禁，不能只重跑这一段",
+    "dynamic-rerun-unsupported": "这次运行含动态展开节点，不支持从节点续跑",
+    "parent-lifecycle-ineligible": "当前运行状态不允许从节点续跑",
+    "convergence-rerun-unsupported": "收敛型运行不支持从节点续跑",
+    "evaluation-rerun-unsupported": "带评估的运行不支持从节点续跑",
+    "budget-rerun-unsupported": "硬预算运行不支持从节点续跑",
+    "workspace-checkpoint-missing": "缺少工作区快照，无法安全地只续跑一段",
+    "skill-snapshot-invalid": "技能快照缺失或损坏，不能接到上次运行上继续",
+    "unresolved-errors-outside-reset-closure": "选中节点之外还有未解决的失败，只重跑这一段不够",
+    "selected-node-missing": "找不到要续跑的起始节点",
+    "ambiguous-skipped-rewrite": "跳过的节点有多个上游失败，无法自动选定起点",
+    "skipped-without-upstream-error": "该节点被跳过且没有明确的上游失败",
+    "parent-facts-invalid": "上次运行的证据不完整或已损坏，不能只续跑一段",
+    RUN_NOT_ACTIVE: "这次运行不在活动状态，不能协作中止",
+    RUN_NOT_CONSOLE_OWNED: "此运行不由当前 Console 持有，暂不支持协作中止",
+    RUNNER_IDENTITY_MISMATCH: "运行身份已变化，不能中止这份过期请求",
+    INTERRUPT_ALREADY_PENDING: "已有一条中止请求等待结算",
+    RUN_ALREADY_TERMINAL: "运行已经结束，没有可中止的活 runner",
+    INTERRUPT_NEEDS_RECONCILE: "中止请求已登记但无法确认 runner 已处理，需要对账",
+};
+function knownCodes() {
+    return Object.keys(REASON_LABELS);
+}
+export function parseIneligibleReasonToken(token) {
+    const trimmed = token.trim().replace(/[.…]+$/, "");
+    if (!trimmed)
+        return null;
+    if (REASON_LABELS[trimmed])
+        return { code: trimmed };
+    const colon = trimmed.lastIndexOf(":");
+    if (colon > 0) {
+        const code = trimmed.slice(colon + 1);
+        const nodeId = trimmed.slice(0, colon);
+        if (REASON_LABELS[code])
+            return { code, nodeId };
+        const match = knownCodes().find((known) => code.length >= 3 && known.startsWith(code));
+        if (match)
+            return { code: match, nodeId };
+    }
+    return REASON_LABELS[trimmed] ? { code: trimmed } : null;
+}
+function collectParsedReasons(input) {
+    const parsed = [];
+    for (const token of input.blockedReasons ?? []) {
+        const item = parseIneligibleReasonToken(String(token));
+        if (item)
+            parsed.push(item);
+    }
+    for (const node of input.blockingNodes ?? []) {
+        const code = node.reasonCode?.trim();
+        if (!code)
+            continue;
+        const item = parseIneligibleReasonToken(node.nodeId ? `${node.nodeId}:${code}` : code);
+        if (item)
+            parsed.push(item);
+    }
+    if (parsed.length === 0 && input.fallbackMessage?.trim()) {
+        const raw = input.fallbackMessage
+            .trim()
+            .replace(/^从节点重跑不具备安全资格[：:]?\s*/, "")
+            .replace(/[。．.]+$/, "");
+        for (const part of raw.split(/[;；]/)) {
+            const item = parseIneligibleReasonToken(part);
+            if (item)
+                parsed.push(item);
+        }
+    }
+    return parsed;
+}
+function uniqueReasonLines(parsed) {
+    const nodesByCode = new Map();
+    for (const item of parsed) {
+        const nodes = nodesByCode.get(item.code) ?? [];
+        if (item.nodeId && !nodes.includes(item.nodeId))
+            nodes.push(item.nodeId);
+        nodesByCode.set(item.code, nodes);
+    }
+    const lines = [];
+    for (const [code, nodes] of nodesByCode) {
+        const label = REASON_LABELS[code];
+        if (!label)
+            continue;
+        if (nodes.length > 0 && code.startsWith("restart-subgraph-contains-")) {
+            lines.push(`${label}（${nodes.join("、")}）`);
+        }
+        else {
+            lines.push(label);
+        }
+    }
+    return lines;
+}
+export function nextActionForIneligibleRerun(reasons) {
+    const haystack = reasons.join("; ");
+    if (haystack.includes("worker-managed-rerun-unsupported") ||
+        reasons.some((reason) => parseIneligibleReasonToken(reason)?.code ===
+            "worker-managed-rerun-unsupported")) {
+        return "下一步：请点下方「重新排队 Worker Task」，从头完整执行。";
+    }
+    return "下一步：请改用「完整重跑任务」，从头完整执行。";
+}
+export function formatIneligibleRerunMessage(input) {
+    const fallback = input.fallbackMessage?.trim();
+    if (fallback?.startsWith("无法从该节点续跑"))
+        return fallback;
+    const parsed = collectParsedReasons(input);
+    const lines = uniqueReasonLines(parsed);
+    const reasonTokens = parsed.map((item) => item.code);
+    const next = nextActionForIneligibleRerun(reasonTokens.length > 0 ? reasonTokens : [fallback ?? ""]);
+    if (lines.length === 0) {
+        return [
+            "无法从该节点续跑。这次续跑不够安全（工作区、控制器或下游步骤不允许只重跑一段）。",
+            next,
+        ].join("\n");
+    }
+    return [
+        "无法从该节点续跑，因为：",
+        ...lines.map((line) => `• ${line}`),
+        "",
+        next,
+    ].join("\n");
+}
+/** Returns rewritten copy when `raw` is a known recovery failure; otherwise null. */
+export function rewriteRecoveryOperatorError(raw) {
+    const text = raw.trim();
+    if (!text)
+        return null;
+    if (text.startsWith("无法从该节点续跑"))
+        return text;
+    if (/从节点重跑不具备安全资格|worker-managed-rerun-unsupported|restart-subgraph-contains-|workspace-drift|controller-drift|binding-drift/.test(text)) {
+        return formatIneligibleRerunMessage({ fallbackMessage: text });
+    }
+    if (/action must be a mutation-gate target/i.test(text)) {
+        return "这个操作不能再走确认门。Worker 启动的任务请直接点「重新排队 Worker Task」；独立运行请点「完整重跑任务」。";
+    }
+    if (/cannot read dagReport run facts/i.test(text)) {
+        return "读不到这次运行的失败报告，不能完整重跑。请先点「查看报告」或「Doctor 诊断」。";
+    }
+    if (/dagRerunPlan run facts unavailable/i.test(text)) {
+        return "读不到从节点续跑的资格结果，不能改走完整重跑。请先点「从节点重跑」查看资格，或先「查看报告」。";
+    }
+    if (/node rerun plan is eligible/i.test(text)) {
+        return "从节点续跑是安全的，请改用「从节点重跑」，不必完整重跑整单。";
+    }
+    if (/does not support autonomous standaloneTaskRerun/i.test(text)) {
+        return "当前失败不适合自动完整重跑。请先点「查看报告」，按建议操作。";
+    }
+    if (/primaryRecovery requires a human decision/i.test(text)) {
+        return "这次失败需要人工决策，不能自动重跑。请先点「查看报告」。";
+    }
+    if (/is not bound to run/i.test(text)) {
+        return "填写的任务 ID 与这次运行不匹配。请使用该运行绑定的原任务 ID。";
+    }
+    if (/cannot read pool doctor/i.test(text)) {
+        return "读不到任务队列状态，暂时不能重新排队。请稍后重试，或先跑 Doctor 诊断。";
+    }
+    if (/not found in the pool doctor inventory/i.test(text)) {
+        return "任务队列里找不到这个任务，不能重新排队。请确认 Task ID 来自 Worker 队列，而不是只填了 DAG 运行 ID。";
+    }
+    if (/only Failed tasks are retry-eligible/i.test(text)) {
+        const status = text.match(/is ([A-Za-z_]+); only Failed/)?.[1];
+        return status
+            ? `该任务当前是「${status}」，只有失败（Failed）的任务才能重新排队。`
+            : "只有失败（Failed）的任务才能重新排队。请先确认任务已失败。";
+    }
+    if (/featureId .+ does not match the pool task/i.test(text)) {
+        return "Feature ID 与队列中的任务不一致。请改用队列里记录的 Feature ID，或留空后重试。";
+    }
+    if (/RUN_NOT_CONSOLE_OWNED|不由当前 Console 持有/.test(text)) {
+        return "此运行不由当前 Console 持有，暂不支持协作中止。请用 Doctor / 报告查看。";
+    }
+    if (/RUNNER_IDENTITY_MISMATCH|运行身份已变化/.test(text)) {
+        return "运行身份已变化，不能中止这份过期请求。请刷新后再试。";
+    }
+    if (/INTERRUPT_ALREADY_PENDING|已有一条中止请求/.test(text)) {
+        return "已有一条中止请求等待当前节点安全收敛。请稍候刷新，不要重复提交。";
+    }
+    if (/RUN_ALREADY_TERMINAL|运行已经结束/.test(text)) {
+        return "运行已经结束，没有可中止的活 runner。请改用报告或对账。";
+    }
+    if (/INTERRUPT_NEEDS_RECONCILE|无法确认 runner 已处理/.test(text)) {
+        return "中止请求已登记，但无法确认 runner 已处理。请用 Doctor 对账，不要当成已经中止。";
+    }
+    if (/RUN_NOT_ACTIVE/.test(text)) {
+        return "这次运行不在本机活动目录，或已经不是 running，不能协作中止。";
+    }
+    return null;
+}