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

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

@@ -1,6 +1,6 @@
 import { access, readFile } from "node:fs/promises";
 import { buildOperatorCapabilitiesDocument } from "../../shared/operator/capabilities.js";
-import { operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
+import { buildOperatorResult, operatorFailed, operatorSucceeded, } from "../../shared/operator/envelope.js";
 import { getTaskPaths } from "../../task/runtime.js";
 import { stageUtf8Text } from "./app-data.js";
 import { ALL_CONFIRMATION_CHALLENGES, hashDagBytes, } from "./dag-confirmation.js";
@@ -15,6 +15,7 @@ import { applyGrillMeAnswer, draftSummary, emptyDraft, isDraftStructurallyComple
 import { toCanonicalDraftForCli, } from "./draft-store.js";
 import { normalizeConsoleWorkflowKind } from "./workflow-kinds.js";
 import { deriveTaskIdentityFromPrd, nextTaskIdRevision, } from "./prd-identity.js";
+import { resolveSiblingAgentWorkerBin } from "./sibling-controller.js";
 const MUTATION_OR_LONG = new Set([
     "newTask",
     "importPrd",
@@ -23,6 +24,9 @@ const MUTATION_OR_LONG = new Set([
     "contractRecover",
     "dagRunTask",
     "runDag",
+    "dagRerun",
+    "standaloneTaskRerun",
+    "workerTaskRetry",
 ]);
 function paramsOf(req) {
     return (req.actionParams ?? {});
@@ -39,10 +43,40 @@ async function runReadCli(ctx, args, command) {
             expectJson: true,
         });
         if (result.json && typeof result.json === "object") {
-            const env = result.json;
+            const raw = result.json;
+            const env = raw;
             if (env.schemaVersion === 1 && typeof env.ok === "boolean") {
                 return env;
             }
+            if (command === "dag rerun plan" && raw.plan && typeof raw.plan === "object") {
+                const plan = raw.plan;
+                if (raw.ok === true) {
+                    return operatorSucceeded(command, plan);
+                }
+                const blockedReasons = Array.isArray(plan.blockedReasons)
+                    ? plan.blockedReasons.map(String)
+                    : [];
+                const blockingNodes = Array.isArray(plan.blockingNodes)
+                    ? plan.blockingNodes.map((n) => [n.nodeId, n.reasonCode].filter(Boolean).join(":"))
+                    : [];
+                const reasons = [...blockedReasons, ...blockingNodes].filter(Boolean);
+                return buildOperatorResult({
+                    command,
+                    ok: false,
+                    outcome: "rejected",
+                    result: plan,
+                    error: {
+                        code: "DAG_RERUN_INELIGIBLE",
+                        message: reasons.length > 0
+                            ? `从节点重跑不具备安全资格：${reasons.slice(0, 6).join("; ")}${reasons.length > 6 ? "…" : ""}`
+                            : "从节点重跑不具备安全资格（eligible=false）",
+                        details: {
+                            eligible: false,
+                            planHash: typeof plan.planHash === "string" ? plan.planHash : undefined,
+                        },
+                    },
+                });
+            }
         }
         if (result.ok && result.exitCode === 0) {
             return operatorSucceeded(command, {
@@ -73,6 +107,7 @@ async function acceptOperation(ctx, input) {
         actionParams: input.actionParams,
         taskId: input.taskId,
         cliArgs: input.cliArgs,
+        ...(input.externalCommand ? { externalCommand: input.externalCommand } : {}),
     });
     if (created.kind === "conflict") {
         return {
@@ -165,6 +200,14 @@ export async function dispatchOperatorAction(ctx, req) {
             const body = await runReadCli(ctx, ["doctor", "--json"], "doctor");
             return { kind: "sync", status: body.ok ? 200 : 400, body };
         }
+        case "dagReport": {
+            const runId = str(p.runId) ?? str(p.dagRunId);
+            if (!runId) {
+                return invalid(action, "runId is required");
+            }
+            const body = await runReadCli(ctx, ["dag", "report", "--run-id", runId, "--json"], "dag report");
+            return { kind: "sync", status: body.ok ? 200 : 400, body };
+        }
         case "status": {
             const taskId = str(p.taskId);
             if (!taskId) {
@@ -894,6 +937,114 @@ export async function dispatchOperatorAction(ctx, req) {
                 ],
             });
         }
+        case "dagRerunPlan": {
+            const runId = str(p.runId);
+            const fromNode = str(p.fromNode);
+            if (!runId || !fromNode) {
+                return invalid(action, "runId and fromNode are required");
+            }
+            const body = await runReadCli(ctx, [
+                "dag",
+                "rerun",
+                "--run-id",
+                runId,
+                "--from-node",
+                fromNode,
+                "--plan",
+                "--json",
+            ], "dag rerun plan");
+            return { kind: "sync", status: body.ok ? 200 : 400, body };
+        }
+        case "dagRerun": {
+            const runId = str(p.runId);
+            const fromNode = str(p.fromNode);
+            const planHash = str(p.planHash);
+            const reason = str(p.reason);
+            const clientRequestId = str(req.clientRequestId);
+            if (!runId || !fromNode || !planHash || !reason || !clientRequestId) {
+                return invalid(action, "runId, fromNode, planHash, reason, and clientRequestId are required");
+            }
+            return acceptOperation(ctx, {
+                action,
+                actionParams: p,
+                clientRequestId,
+                cliArgs: [
+                    "dag",
+                    "rerun",
+                    "--run-id",
+                    runId,
+                    "--from-node",
+                    fromNode,
+                    "--plan-hash",
+                    planHash,
+                    "--request-id",
+                    clientRequestId,
+                    "--reason",
+                    reason,
+                    "--json",
+                ],
+            });
+        }
+        case "standaloneTaskRerun": {
+            const runId = str(p.runId);
+            const reason = str(p.reason);
+            const clientRequestId = str(req.clientRequestId);
+            if (!runId || !reason || !clientRequestId) {
+                return invalid(action, "runId, reason, and clientRequestId are required");
+            }
+            const cliArgs = [
+                "dag",
+                "rerun-task",
+                "--run-id",
+                runId,
+                "--reason",
+                reason,
+                "--request-id",
+                clientRequestId,
+                "--json",
+            ];
+            const profile = str(p.profile);
+            const taskId = str(p.taskId);
+            if (profile)
+                cliArgs.push("--profile", profile);
+            if (taskId)
+                cliArgs.push("--task-id", taskId);
+            return acceptOperation(ctx, {
+                action,
+                actionParams: p,
+                clientRequestId,
+                taskId,
+                cliArgs,
+            });
+        }
+        case "workerTaskRetry": {
+            const taskId = str(p.taskId);
+            const featureId = str(p.featureId);
+            const reason = str(p.reason);
+            const clientRequestId = str(req.clientRequestId);
+            if (!taskId || !reason || !clientRequestId) {
+                return invalid(action, "taskId, reason, and clientRequestId are required");
+            }
+            const args = [
+                "task",
+                "retry",
+                taskId,
+                "--repo",
+                ctx.repoRoot,
+                "--reason",
+                reason,
+            ];
+            if (featureId)
+                args.push("--feature-id", featureId);
+            return acceptOperation(ctx, {
+                action,
+                actionParams: p,
+                clientRequestId,
+                taskId,
+                cliArgs: args,
+                externalCommand: resolveSiblingAgentWorkerBin(),
+            });
+        }
         default:
             return {
                 kind: "error",

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

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

package/dist/worker/console/pi-readiness.js

@@ -11,6 +11,8 @@ const SETUP_BLOCKED = Object.freeze([
     "contractAdopt",
     "dagRunTask",
     "runDag",
+    "dagRerun",
+    "standaloneTaskRerun",
     "prepareDagConfirmation",
     "interviewStart",
     "interviewTurn",
@@ -21,6 +23,8 @@ const DEGRADED_BLOCKED = Object.freeze([
     "contractAdopt",
     "dagRunTask",
     "runDag",
+    "dagRerun",
+    "standaloneTaskRerun",
     // new Interview may resume; brand-new apply/run still blocked
 ]);
 /** Default Interview / DAG model matrix (provider, modelId). */

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

@@ -6,51 +6,106 @@ const CTA = {
     report: {
         id: "report",
         label: "查看报告",
-        action: "status",
-        commandHint: "loop-agent dag report --run-id <run-id>",
+        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 run-dag --resume --run-id <run-id>",
     },
     reconcile: {
         id: "reconcile",
         label: "对账 / reconcile",
         requiresReason: true,
+        lane: "dag",
+        guide: "状态不一致时先对账，再决定是否重跑（需原因）",
         commandHint: "loop-agent dag reconcile-run --run-id <run-id> --reason <structured-reason>",
     },
     regenerate: {
         id: "regenerate",
         label: "重新生成契约/计划",
+        lane: "dag",
+        guide: "契约/计划过期时：回任务页或经 CLI 重新 run-task（本页仅提示）",
         commandHint: "loop-agent dag run-task <task-id> --profile auto",
     },
     observeLink: {
         id: "observeLink",
-        label: "打开检视",
+        label: "全屏观测",
         action: "observeLink",
+        lane: "dag",
+        guide: "打开完整 Inspect 画布；顶栏可返回操作台",
         commandHint: "agent-worker console serve --repo . --port 8790",
     },
+    dagRerun: {
+        id: "dagRerun",
+        label: "从节点重跑",
+        requiresReason: true,
+        action: "dagRerun",
+        lane: "dag",
+        guide: "子图重跑：需选起点且 plan 合格；含 writer 的早期节点常不可用",
+        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: "整单重跑：失败类默认首选；需确认原因后提交",
+        commandHint: "loop-agent dag rerun-task --run-id <run-id> --reason <reason> --request-id <key>",
+    },
+    workerTaskRetry: {
+        id: "workerTaskRetry",
+        label: "重新排队 Worker Task",
+        requiresReason: true,
+        action: "workerTaskRetry",
+        lane: "worker",
+        guide: "仅 Worker 队列任务失败时使用，不要与 DAG 重跑混用",
+        commandHint: "agent-worker task retry <task-id> --feature-id <feature-id> --repo . --reason <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", "resume", "regenerate"],
+    "verification-failed": [
+        "report",
+        "doctor",
+        "standaloneTaskRerun",
+        "dagRerun",
+        "resume",
+        "regenerate",
+    ],
     "orphan-unknown": ["report", "doctor", "reconcile"],
-    "terminal-failed": ["report", "doctor", "resume", "regenerate"],
+    "terminal-failed": [
+        "report",
+        "doctor",
+        "dagRerun",
+        "standaloneTaskRerun",
+        "workerTaskRetry",
+        "regenerate",
+    ],
     "terminal-succeeded": ["report", "observeLink"],
     "needs-reconcile": ["report", "doctor", "reconcile", "regenerate"],
 };
@@ -68,6 +123,62 @@ 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 / reconcile) stay in the
+ * policy matrix for docs, but must not appear as dead buttons.
+ */
+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 safe whole-task recovery over node rerun when early writers often block.
+ */
+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("standaloneTaskRerun", "dagRerun", "doctor", "report");
+        case "pause-on-human":
+            return pick("doctor", "report");
+        case "needs-reconcile":
+        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).
  */

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/resolve-dag-run-for-task.js

@@ -1,9 +1,10 @@
 /**
- * Resolve the newest DAG run id for a harness task under `.harness/dag-runs`.
- * Used by Console observeLink so task-scoped opens land on `#/dag/<runId>`.
+ * Resolve / list DAG run ids for a harness task under `.harness/dag-runs`.
+ * Used by Console observeLink and Recovery candidates API.
  */
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
+import { sortRecoveryRunCandidates, } from "./recovery-selection.js";
 const LIFECYCLE_ORDER = ["active", "paused", "completed"];
 async function readTaskIdFromRunDir(runDir) {
     const runJsonPath = path.join(runDir, "run.json");
@@ -23,13 +24,20 @@ async function readTaskIdFromRunDir(runDir) {
     }
     return undefined;
 }
-/**
- * Prefer active/paused over completed; within a lifecycle, newest mtime wins.
- */
-export async function resolveLatestDagRunIdForTask(repoRoot, taskId) {
-    const wanted = taskId.trim();
-    if (!wanted)
-        return undefined;
+async function readRunMeta(runDir) {
+    try {
+        const raw = JSON.parse(await readFile(path.join(runDir, "state.json"), "utf8"));
+        return {
+            status: typeof raw.status === "string" ? raw.status : undefined,
+            title: typeof raw.title === "string" ? raw.title : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+async function scanDagRunCandidates(repoRoot, taskIdFilter) {
+    const wanted = taskIdFilter?.trim() || undefined;
     const matches = [];
     for (const lifecycle of LIFECYCLE_ORDER) {
         const lifecycleDir = path.join(repoRoot, ".harness", "dag-runs", lifecycle);
@@ -54,15 +62,29 @@ export async function resolveLatestDagRunIdForTask(repoRoot, taskId) {
             if (!st.isDirectory())
                 continue;
             const boundTaskId = await readTaskIdFromRunDir(runDir);
-            if (boundTaskId !== wanted)
+            if (wanted && boundTaskId !== wanted)
                 continue;
+            const meta = await readRunMeta(runDir);
             matches.push({
                 dagRunId: name,
                 lifecycle,
                 mtimeMs: st.mtimeMs,
+                status: meta.status,
+                title: meta.title,
+                ...(boundTaskId ? { taskId: boundTaskId } : {}),
             });
         }
     }
+    return matches;
+}
+/**
+ * Prefer active/paused over completed; within a lifecycle, newest mtime wins.
+ */
+export async function resolveLatestDagRunIdForTask(repoRoot, taskId) {
+    const wanted = taskId.trim();
+    if (!wanted)
+        return undefined;
+    const matches = await scanDagRunCandidates(repoRoot, wanted);
     if (matches.length === 0)
         return undefined;
     const lifecycleRank = (value) => LIFECYCLE_ORDER.indexOf(value);
@@ -72,5 +94,22 @@ export async function resolveLatestDagRunIdForTask(repoRoot, taskId) {
             return life;
         return b.mtimeMs - a.mtimeMs;
     });
-    return matches[0];
+    const top = matches[0];
+    return {
+        dagRunId: top.dagRunId,
+        lifecycle: top.lifecycle,
+        mtimeMs: top.mtimeMs,
+    };
+}
+/**
+ * List DAG runs for Recovery pickers.
+ * - With taskId: only runs bound to that task
+ * - Without taskId: recent runs across lifecycles (capped)
+ * Sorted for recovery attention (failed/paused first).
+ */
+export async function listDagRunsForRecovery(repoRoot, options) {
+    const taskId = options?.taskId?.trim() || undefined;
+    const limit = Math.min(Math.max(options?.limit ?? 40, 1), 100);
+    const matches = await scanDagRunCandidates(repoRoot, taskId);
+    return sortRecoveryRunCandidates(matches).slice(0, limit);
 }

package/dist/worker/console/routes.js

@@ -6,6 +6,7 @@ import { openSseResponse, parseLastEventId, writeSseEvent, } from "./operation-s
 import { buildOperatorSurfaceHealthV1 } from "./operator-surface-health.js";
 import { ROUTES } from "../observe/routes.js";
 import { evaluateMutationGate, injectConfirmationTokenScript, isMutationMethod, } from "./security.js";
+import { listDagRunsForRecovery } from "./resolve-dag-run-for-task.js";
 export function sendJson(res, status, body, extraHeaders) {
     const payload = JSON.stringify(body);
     res.writeHead(status, {
@@ -98,6 +99,21 @@ async function handleReadiness(_req, res, ctx) {
     }
     sendJson(res, 200, report);
 }
+async function handleRecoveryCandidates(_req, res, ctx, url) {
+    const taskId = url.searchParams.get("taskId")?.trim() || undefined;
+    const limitRaw = url.searchParams.get("limit");
+    const limit = limitRaw ? Number.parseInt(limitRaw, 10) : undefined;
+    const runs = await listDagRunsForRecovery(ctx.repoRoot, {
+        taskId,
+        ...(Number.isFinite(limit) ? { limit } : {}),
+    });
+    sendJson(res, 200, {
+        ok: true,
+        schemaVersion: 1,
+        taskId: taskId ?? null,
+        runs,
+    });
+}
 async function handleSessionPing(req, res, ctx) {
     const failure = evaluateMutationGate(req, {
         bootToken: ctx.bootToken.value,
@@ -328,6 +344,10 @@ export async function handleConsoleOperatorRequest(req, res, ctx) {
         await handleReadiness(req, res, ctx);
         return true;
     }
+    if (method === "GET" && pathname === "/api/operator/v1/recovery/candidates") {
+        await handleRecoveryCandidates(req, res, ctx, url);
+        return true;
+    }
     // Phase 1 mutation stub for security tests
     if (method === "POST" && pathname === "/api/session/ping") {
         await handleSessionPing(req, res, ctx);