@tea-agent/loop-agent 0.1.0-fe-test.0

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

@@ -0,0 +1,320 @@
+/**
+ * Recovery UI CTA matrix (design §5.5.3).
+ * Pure table-driven policy — no Cancel, no primary "edit code" CTA.
+ */
+const CTA = {
+    report: {
+        id: "report",
+        label: "查看报告",
+        action: "dagReport",
+        lane: "dag",
+        guide: "看失败分类与建议动作（交接报告摘要）",
+        commandHint: "loop-agent dag report --run-id <run-id> --json",
+    },
+    doctor: {
+        id: "doctor",
+        label: "Doctor 诊断",
+        action: "doctor",
+        lane: "dag",
+        guide: "只读诊断：检查 Console / Pi / 仓库就绪，不是重跑前置",
+        commandHint: "agent-worker console doctor --repo .",
+    },
+    decision: {
+        id: "decision",
+        label: "人工决策",
+        lane: "dag",
+        guide: "暂停等人时：先看 doctor 输出再做决策（经 CLI）",
+        commandHint: "loop-agent dag doctor --run-id <run-id> --markdown",
+    },
+    resume: {
+        id: "resume",
+        label: "恢复运行",
+        lane: "dag",
+        guide: "仅当运行可安全 resume 时使用（经 CLI）",
+        commandHint: "loop-agent task advance <task-id> --json",
+    },
+    reconcile: {
+        id: "reconcile",
+        label: "对账 / reconcile",
+        requiresReason: true,
+        action: "dagReconcileRun",
+        lane: "dag",
+        guide: "Orphan/中断时先对账归档（默认 supersede）；runner 仍存活时勿盲 supersede",
+        commandHint: "loop-agent dag reconcile-run --run-id <run-id> --action supersede --reason <structured-reason>",
+    },
+    regenerate: {
+        id: "regenerate",
+        label: "重新生成契约/计划",
+        lane: "dag",
+        guide: "契约/计划过期时：回任务页或经 CLI 重新 task advance（本页仅提示）",
+        commandHint: "loop-agent task advance <task-id> --json",
+    },
+    observeLink: {
+        id: "observeLink",
+        label: "全屏观测",
+        action: "observeLink",
+        lane: "dag",
+        guide: "打开完整 Inspect 画布；顶栏可返回操作台",
+        commandHint: "agent-worker console --repo . --port 8790",
+    },
+    dagRerun: {
+        id: "dagRerun",
+        label: "从节点重跑",
+        requiresReason: true,
+        action: "dagRerun",
+        lane: "dag",
+        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: {
+        id: "standaloneTaskRerun",
+        label: "完整重跑任务",
+        requiresReason: true,
+        action: "standaloneTaskRerun",
+        lane: "dag",
+        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: {
+        id: "workerTaskRetry",
+        label: "重新排队 Worker Task",
+        requiresReason: true,
+        action: "workerTaskRetry",
+        lane: "worker",
+        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"],
+    "contract-drift": ["report", "doctor", "decision", "reconcile", "regenerate"],
+    "runtime-mismatch": ["report", "doctor", "reconcile", "regenerate"],
+    "pause-on-human": ["decision", "resume", "report", "doctor"],
+    "verification-failed": [
+        "report",
+        "doctor",
+        "dagRerun",
+        "standaloneTaskRerun",
+        "resume",
+        "regenerate",
+    ],
+    // Stall/quiet/unknown: observe + doctor only — do not offer supersede while
+    // runner may still be alive (eligibility fail-closes, but UI should not tease).
+    "orphan-unknown": ["report", "doctor"],
+    "terminal-failed": [
+        "report",
+        "doctor",
+        "dagRerun",
+        "standaloneTaskRerun",
+        "workerTaskRetry",
+        "regenerate",
+    ],
+    "terminal-succeeded": ["report", "observeLink"],
+    "needs-reconcile": ["report", "doctor", "reconcile", "regenerate"],
+    "running-active": ["interrupt", "report", "doctor", "observeLink"],
+};
+const FORBIDDEN_LABELS = [
+    "直接改代码",
+    "edit code",
+    "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".
+ */
+export function allowedRecoveryCtas(factClass) {
+    const ids = MATRIX[factClass] ?? MATRIX["orphan-unknown"];
+    return ids.map((id) => CTA[id]);
+}
+/** Split CTAs so Console UI never mixes DAG runtime and Worker Task lanes. */
+export function partitionRecoveryCtas(ctas) {
+    const dag = [];
+    const worker = [];
+    for (const cta of ctas) {
+        if (cta.lane === "worker")
+            worker.push(cta);
+        else
+            dag.push(cta);
+    }
+    return { dag, worker };
+}
+/**
+ * Console only shows CTAs that actually dispatch an operator action.
+ * Pure CLI-hint rows (regenerate / decision / resume) stay in the policy
+ * matrix for docs, but must not appear as dead buttons. reconcile is wired
+ * to dagReconcileRun (structured reason required).
+ */
+export function isConsoleExecutableRecoveryCta(cta) {
+    return typeof cta.action === "string" && cta.action.trim().length > 0;
+}
+/** Matrix CTAs that the Official Console may render as buttons. */
+export function consoleRecoveryCtas(factClass) {
+    return allowedRecoveryCtas(factClass).filter(isConsoleExecutableRecoveryCta);
+}
+/**
+ * Suggested primary CTA for the current fact class.
+ * Prefer node subgraph rerun (cheaper) over whole-task rerun; plan gate still fail-closes unsafe closures.
+ */
+export function recommendedRecoveryCtaId(factClass) {
+    const allowed = new Set(consoleRecoveryCtas(factClass).map((c) => c.id));
+    const pick = (...ids) => {
+        for (const id of ids) {
+            if (allowed.has(id))
+                return id;
+        }
+        return null;
+    };
+    switch (factClass) {
+        case "terminal-failed":
+        case "verification-failed":
+            return pick("dagRerun", "standaloneTaskRerun", "doctor", "report");
+        case "pause-on-human":
+            return pick("doctor", "report");
+        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");
+        case "validation-failed":
+            return pick("doctor", "report");
+        case "terminal-succeeded":
+            return pick("observeLink", "report");
+        case "orphan-unknown":
+        default:
+            return pick("doctor", "report");
+    }
+}
+/**
+ * Negative product invariants for recovery matrix (test + docs).
+ */
+export function recoveryMatrixInvariants() {
+    const allCtaIds = Object.keys(CTA);
+    const factClasses = Object.keys(MATRIX);
+    return {
+        forbiddenLabels: FORBIDDEN_LABELS,
+        allCtaIds,
+        factClasses,
+    };
+}
+/**
+ * Best-effort classification from operation/DAG surface strings for MVP UI.
+ * Prefer structured fields when available; unknown → orphan-unknown.
+ */
+export function classifyRecoveryFact(input) {
+    if (input.needsReconcile)
+        return "needs-reconcile";
+    const code = (input.errorCode ?? "").toLowerCase();
+    const state = (input.operationState ?? "").toLowerCase();
+    const dag = (input.dagStatus ?? "").toLowerCase();
+    const failure = (input.failureCategory ?? "").toLowerCase();
+    if (code.includes("validation") ||
+        code.includes("invalid") ||
+        state.includes("validation")) {
+        return "validation-failed";
+    }
+    if (code.includes("contract") ||
+        code.includes("drift") ||
+        code.includes("binding")) {
+        return "contract-drift";
+    }
+    if (code.includes("runtime") ||
+        code.includes("mismatch") ||
+        code.includes("fingerprint")) {
+        return "runtime-mismatch";
+    }
+    if (code.includes("human") ||
+        state.includes("paused") ||
+        dag.includes("paused") ||
+        state.includes("awaiting")) {
+        return "pause-on-human";
+    }
+    if (code.includes("verif") || state.includes("verif")) {
+        return "verification-failed";
+    }
+    // Controller interrupt / orphaned mid-run: reconcile first (not blind rerun).
+    if (failure === "controller-interrupted" ||
+        code.includes("controller-interrupted") ||
+        code.includes("interrupted") ||
+        dag === "interrupted" ||
+        dag === "orphaned" ||
+        state.includes("controller-interrupted") ||
+        state.includes("interrupted")) {
+        return "needs-reconcile";
+    }
+    // Live stall / quiet while runner lease may still be fresh — observe/doctor only
+    // (Console executable CTAs: report + doctor; reconcile stays CLI-hint).
+    if (dag === "running-suspected-stall" ||
+        dag === "running-quiet" ||
+        dag === "suspected-stall" ||
+        dag.includes("suspected-stall") ||
+        state.includes("suspected-stall")) {
+        return "orphan-unknown";
+    }
+    if (dag === "running" || dag === "active") {
+        return "running-active";
+    }
+    if (state === "succeeded" ||
+        state === "completed" ||
+        state === "finished" ||
+        dag === "succeeded" ||
+        dag === "completed" ||
+        dag === "finished") {
+        return "terminal-succeeded";
+    }
+    if (state === "failed" ||
+        state.includes("fail") ||
+        dag === "failed" ||
+        dag === "partial_failed" ||
+        code.includes("fail")) {
+        return "terminal-failed";
+    }
+    if (code.includes("reconcil") || state.includes("reconcil")) {
+        return "needs-reconcile";
+    }
+    return "orphan-unknown";
+}

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;
+}

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

@@ -0,0 +1,107 @@
+/**
+ * Pure helpers for Operator Console recovery pickers (run + from-node).
+ */
+const FAILED_NODE = new Set(["failed", "error", "partial_failed"]);
+const ATTENTION_NODE = new Set(["blocked", "paused", "awaiting_human"]);
+function norm(value) {
+    return (value ?? "").trim().toLowerCase();
+}
+export function isFailedNodeStatus(status) {
+    return FAILED_NODE.has(norm(status));
+}
+function runAttentionRank(run) {
+    const status = norm(run.status);
+    if (FAILED_NODE.has(status) || status.includes("fail"))
+        return 0;
+    if (run.lifecycle === "paused" || status === "paused")
+        return 1;
+    if (run.lifecycle === "active")
+        return 2;
+    return 3;
+}
+/** Prefer failed → paused → active → completed; newest mtime within tier. */
+export function sortRecoveryRunCandidates(runs) {
+    return [...runs].sort((a, b) => {
+        const rank = runAttentionRank(a) - runAttentionRank(b);
+        if (rank !== 0)
+            return rank;
+        return b.mtimeMs - a.mtimeMs;
+    });
+}
+export function pickDefaultRecoveryRunId(runs) {
+    const sorted = sortRecoveryRunCandidates(runs);
+    return sorted[0]?.dagRunId;
+}
+function nodeAttentionRank(node) {
+    const status = norm(node.status);
+    if (FAILED_NODE.has(status))
+        return 0;
+    if (ATTENTION_NODE.has(status))
+        return 1;
+    return 2;
+}
+/** Prefer failed nodes, then attention states, then stable id order. */
+export function sortRecoveryNodeCandidates(nodes) {
+    return [...nodes].sort((a, b) => {
+        const rank = nodeAttentionRank(a) - nodeAttentionRank(b);
+        if (rank !== 0)
+            return rank;
+        return a.nodeId.localeCompare(b.nodeId);
+    });
+}
+/** Default from-node: first failed (or attention) node; undefined if none. */
+export function pickDefaultRecoveryNodeId(nodes) {
+    const sorted = sortRecoveryNodeCandidates(nodes);
+    const preferred = sorted.find((n) => isFailedNodeStatus(n.status) || ATTENTION_NODE.has(norm(n.status)));
+    return preferred?.nodeId ?? sorted[0]?.nodeId;
+}
+export function formatRecoveryRunLabel(run) {
+    const status = run.status?.trim() || run.lifecycle;
+    const shortId = run.dagRunId.length > 36
+        ? `${run.dagRunId.slice(0, 18)}…${run.dagRunId.slice(-8)}`
+        : run.dagRunId;
+    return `${shortId} · ${status}`;
+}
+export function formatRecoveryNodeLabel(node) {
+    const status = node.status?.trim() || "unknown";
+    const name = node.label?.trim();
+    return name && name !== node.nodeId
+        ? `${node.nodeId} · ${status} · ${name}`
+        : `${node.nodeId} · ${status}`;
+}
+/**
+ * Structured recovery reason for Console confirm dialog.
+ * Prefer selected run/node failure facts over stale operator errors.
+ */
+export function buildRecoveryReason(input) {
+    const action = input.actionLabel?.trim() || "恢复";
+    const lines = [`operator-recovery: ${action}`];
+    const runId = input.dagRunId?.trim();
+    if (runId) {
+        const runStatus = input.runStatus?.trim();
+        lines.push(runStatus ? `run=${runId} (${runStatus})` : `run=${runId}`);
+    }
+    const nodeId = input.fromNodeId?.trim();
+    if (nodeId) {
+        const nodeStatus = input.nodeStatus?.trim();
+        lines.push(nodeStatus ? `from-node=${nodeId} (${nodeStatus})` : `from-node=${nodeId}`);
+    }
+    const fact = input.factClassLabel?.trim();
+    if (fact)
+        lines.push(`fact=${fact}`);
+    const detail = input.nodeError?.trim() ||
+        input.errorMessage?.trim() ||
+        (input.errorCode?.trim() ? `code=${input.errorCode.trim()}` : "");
+    if (detail)
+        lines.push(`detail=${detail.replace(/\s+/g, " ").slice(0, 280)}`);
+    return lines.join("\n").slice(0, 500);
+}
+/** True when reason looks like an auto-generated template (safe to refresh). */
+export function isAutoRecoveryReason(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return true;
+    return (trimmed === "operator-recovery" ||
+        trimmed.startsWith("operator-recovery:") ||
+        trimmed.startsWith("recovery:"));
+}

package/dist/worker/console/repo-fingerprint.js

@@ -0,0 +1,35 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import path from "node:path";
+/**
+ * Normalize a worktree root for repoFingerprintV1:
+ * realpath → Windows drive letter uppercased → `/` separators → strip trailing `/`
+ * (except a bare root). No extra case-folding on macOS/Windows.
+ */
+export function normalizeWorktreeRealpath(repoRoot) {
+    // The legacy JS implementation preserves an input 8.3 path such as
+    // C:\\Users\\MICROS~1 on Windows. The native implementation expands the
+    // short and long aliases to the same physical path before hashing.
+    const absolute = path.resolve(repoRoot);
+    let resolved = process.platform === "win32"
+        ? realpathSync.native(absolute)
+        : realpathSync(absolute);
+    if (/^[a-zA-Z]:/.test(resolved)) {
+        resolved = resolved[0].toUpperCase() + resolved.slice(1);
+    }
+    resolved = resolved.replace(/\\/g, "/");
+    if (resolved.length > 1 && resolved.endsWith("/")) {
+        resolved = resolved.replace(/\/+$/, "");
+    }
+    return resolved;
+}
+/**
+ * Design §5.1: sha256("loop-console-repo-v1\0" + normalizedWorktreeRealpath)
+ * Returns lowercase hex digest (no sha256: prefix).
+ */
+export function repoFingerprintV1(repoRoot) {
+    const normalized = normalizeWorktreeRealpath(repoRoot);
+    return createHash("sha256")
+        .update(`loop-console-repo-v1\0${normalized}`, "utf8")
+        .digest("hex");
+}