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

package/CHANGELOG.md

@@ -2,13 +2,37 @@
 
 ## [Unreleased]
 
+## [0.20.1] - 2026-07-24
+
 ### 新增
 
+- LLM/provider 偶发失败时可在同节点自动重试；reviewer 漏写 `VERDICT` 等协议错误也会在节点内纠错重试，不必等下游 gate 才失败
+- 新增 `loop-agent dag rerun`：在安全资格通过时，从选定节点重跑只读子图，并保留父 run 证据与 import 审计
+- 新增 `loop-agent dag rerun-task`：一键完整重跑 standalone 任务（重新生成、校验并执行），不修改父 run
+- Operator Console Recovery 提供明确动作：从节点重跑、完整重跑任务、重新排队 Worker Task（不再使用含糊的「重试」）
 - 前端规范读取将知识库与 `openspec/` 作为并列来源：无论知识库是否可用或命中，均继续递归枚举 `<repoRoot>/openspec/**` 并读取索引与任务相关规范正文。`discoverFrontendProjectCapability` 在没有 `package.json` 或 `package.json` 不可读时仍能发现 `openspec/**` 规范候选。
 - 前端预写门禁会校验 plan/design-review 的真实读取事件；生成期存在 `openspec` 规范候选但没有成功读取匹配文件时，在 writer 执行前阻断 DAG 并列出候选路径、检查节点和原因。
 - Dashboard 规范证据 API/UI 分别展示知识库查询、`openspec` 检索和 `openspec` 成功读取证据，三种类别独立展示。
 - 前端规范证据 API 新增 `openspecReads` 与 `openspecSearches` 字段，与通用 `specReads`/`specSearches` 并行。
 
+### 改进
+
+- Operator Console「恢复」面板自动拉取 DAG 运行与节点候选，优先展示失败项并以选择器填入，仍可手动输入
+- 从节点重跑预检失败时展示真实安全资格阻断原因，不再误报为「无法获取 planHash」
+- 恢复页长操作（完整重跑等）会回写终态成功/失败；不再只提示「已接受」后无下文
+- 恢复原因按所选 run/节点与失败事实自动预填，并给出三步操作指引；手动编辑不会被覆盖
+- 恢复页将「DAG 运行恢复」与「Worker Task 重排队」分成独立区域，避免把 runtime DAG 与 Task Pool 动作混在一起
+- 恢复页去掉高亮「打开检视」，避免与顶部「观测」入口重复误点；需要时用「侧栏预览」或「全屏观测」
+- 恢复页「侧栏预览」在本页打开可关闭；全屏观测顶栏改为「返回操作台」
+- 修复侧栏预览：兼容 Observe 的 `nodeId`/`label`，并安全格式化 session-events（避免 React 渲染对象导致整页空白）
+- 恢复 CTA：查看报告改走 `dag report`（按 run ID）；推荐动作仅用橙色主按钮标出，悬停看说明
+- 从节点重跑 / 完整重跑任务点击后，在按钮下方出现「确定 / 取消」确认条
+- 恢复页不再展示仅弹 CLI 提示的按钮（如「重新生成契约/计划」）
+- 「查看报告」在按钮下方展示交接摘要（失败分类与建议），不再只闪顶部提示
+- 控制器指纹漂移错误改为中文提示：请重启 Console，勿在会话中途重建
+- frontend-test 环境预检：在生成用例前对冻结的非生产 `baseUrl` 做 curl 可达性探测；不可达或缺少 curl 时以 `frontend-base-url-unreachable` / `curl-unavailable` 阻断 generate/map，并写入 `environmentProbe` 事实。节点 5 manifest 物化改为 ruleId 失败分类、map 配额预检与 temp+rename 原子写入；生成/清单/执行强制 playwright-cli-only，U/D 场景要求当前用户数据归属或 create/Mock/blocked。
+- 前端测试 DAG 的证据自检改为按用例降级：个别缺失、空白或格式错误的证据会如实标为 blocked 并继续生成复盘报告；只有全部用例都未产生任何证据内容或证据路径不安全时才失败。
+
 ## [0.20.0] - 2026-07-23
 
 ### 新增

package/dist/application/dag/args.js

@@ -259,6 +259,7 @@ export function parseRunDagArgs(args, defaultCwd) {
     let canvasName;
     let canvasesDir;
     let eventsJsonlPath;
+    let workerAssociation;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
         if (arg === "--dag") {
@@ -309,6 +310,12 @@ export function parseRunDagArgs(args, defaultCwd) {
         else if (arg.startsWith("--events-jsonl=")) {
             eventsJsonlPath = arg.slice("--events-jsonl=".length);
         }
+        else if (arg === "--worker-association") {
+            workerAssociation = parseWorkerAssociation(args[++i]);
+        }
+        else if (arg.startsWith("--worker-association=")) {
+            workerAssociation = parseWorkerAssociation(arg.slice("--worker-association=".length));
+        }
         else if (arg === "--json") {
             // Accepted for operator/console callers; run-dag always emits JSON stdout.
         }
@@ -336,8 +343,30 @@ export function parseRunDagArgs(args, defaultCwd) {
         canvasName,
         canvasesDir,
         eventsJsonlPath,
+        ...(workerAssociation ? { workerAssociation } : {}),
     };
 }
+function parseWorkerAssociation(raw) {
+    if (!raw?.trim()) {
+        throw new Error("run-dag --worker-association requires JSON");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("run-dag --worker-association must be valid JSON");
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        parsed.schemaVersion !== 1 ||
+        typeof parsed.workerRunId !== "string" ||
+        typeof parsed.featureId !== "string" ||
+        typeof parsed.taskId !== "string") {
+        throw new Error("run-dag --worker-association requires {schemaVersion:1,workerRunId,featureId,taskId}");
+    }
+    return parsed;
+}
 export function parseDagReportArgs(args) {
     let runId;
     let lifecycle = "all";

package/dist/application/dag/run-dag.js

@@ -87,8 +87,10 @@ export async function runDagUseCase(input) {
         maxConcurrent: input.maxConcurrent,
         runId: input.runId,
         observer,
+        ...(input.workerAssociation
+            ? { workerAssociation: input.workerAssociation }
+            : {}),
     });
-    await eventObserver?.flush();
     const canvasError = await flushCanvasSafely(canvas);
     if (resolvedCanvasPath) {
         return {

package/dist/cli/command-definitions.js

@@ -36,6 +36,8 @@ import { runDagApprove } from "../commands/dag-approve.js";
 import { runDagReject } from "../commands/dag-reject.js";
 import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
+import { runDagRerunTask } from "../commands/dag-rerun-task.js";
+import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagResume } from "../commands/dag-resume.js";
 import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
 import { runDagDoctor, runDagStatus } from "../workflows/dag/lifecycle.js";
@@ -131,6 +133,8 @@ const DAG_SUBCOMMANDS = [
     "report",
     "closeout-draft",
     "reconcile-run",
+    "rerun",
+    "rerun-task",
     "reconcile-tasks",
     "final-verification",
     "decision",
@@ -614,6 +618,16 @@ export const COMMAND_DEFINITIONS = [
                 await runDagReconcileRun(repoRoot, reconcileRunArgs);
                 return;
             }
+            if (subcommand === "rerun") {
+                const rerunArgs = rest.filter((arg) => Boolean(arg));
+                await runDagRerun(repoRoot, rerunArgs);
+                return;
+            }
+            if (subcommand === "rerun-task") {
+                const rerunTaskArgs = rest.filter((arg) => Boolean(arg));
+                await runDagRerunTask(repoRoot, rerunTaskArgs);
+                return;
+            }
             if (subcommand === "reconcile-tasks") {
                 const reconcileArgs = rest.filter((arg) => Boolean(arg));
                 await runDagReconcileTasks(repoRoot, reconcileArgs);
@@ -647,7 +661,7 @@ export const COMMAND_DEFINITIONS = [
         adapter: "required",
         tier: "primary",
         intent: "Execute a reviewed Agent DAG spec.",
-        usage: "run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>]",
+        usage: "run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>] [--worker-association <json>]",
         handler: async ({ repoRoot, subcommand, rest }) => {
             const runDagArgs = [subcommand, ...rest].filter((arg) => Boolean(arg));
             await runRunDag(repoRoot, runDagArgs);

package/dist/cli/program.js

@@ -12,6 +12,8 @@ import { runDagFinalVerification } from "../commands/dag-final-verification.js";
 import { runDagInitHybrid } from "../commands/dag-init-hybrid.js";
 import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
 import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
+import { runDagRerunTask } from "../commands/dag-rerun-task.js";
+import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagReject } from "../commands/dag-reject.js";
 import { runDagCloseoutDraft, runDagReport } from "../commands/dag-report.js";
 import { runDagResume } from "../commands/dag-resume.js";
@@ -346,6 +348,12 @@ async function runDagAction(repoRoot, subcommand, rest) {
         case "reconcile-run":
             await runDagReconcileRun(repoRoot, args);
             return;
+        case "rerun":
+            await runDagRerun(repoRoot, args);
+            return;
+        case "rerun-task":
+            await runDagRerunTask(repoRoot, args);
+            return;
         case "reconcile-tasks":
             await runDagReconcileTasks(repoRoot, args);
             return;
@@ -365,7 +373,7 @@ async function runDagAction(repoRoot, subcommand, rest) {
             throw new Error("usage: dag decision <inspect|validate> --run-id <id> [--node-id <node-id>]");
         }
         default:
-            throw new Error("usage: dag <init-hybrid|run-task|validate|workflow-plan|workflow-validate|workflow-compile|approve|reject|resume|status|doctor|report|closeout-draft|reconcile-run|reconcile-tasks|final-verification|decision> ...");
+            throw new Error("usage: dag <init-hybrid|run-task|validate|workflow-plan|workflow-validate|workflow-compile|approve|reject|resume|status|doctor|report|closeout-draft|reconcile-run|rerun|rerun-task|reconcile-tasks|final-verification|decision> ...");
     }
 }
 function compactArgs(args) {
@@ -507,6 +515,8 @@ function addDagCommand(program, defaultRepoRoot) {
         "report",
         "closeout-draft",
         "reconcile-run",
+        "rerun",
+        "rerun-task",
         "reconcile-tasks",
         "final-verification",
     ], defaultRepoRoot);

package/dist/commands/dag-rerun-task.js

@@ -0,0 +1,19 @@
+import { parseDagRerunTaskArgs, rerunStandaloneTask, } from "../workflows/dag/rerun-task.js";
+export { parseDagRerunTaskArgs, rerunStandaloneTask };
+export async function runDagRerunTask(repoRoot, rawArgs) {
+    const parsed = parseDagRerunTaskArgs(rawArgs);
+    const result = await rerunStandaloneTask({
+        cwd: repoRoot,
+        parentRunId: parsed.parentRunId,
+        reason: parsed.reason,
+        requestId: parsed.requestId,
+        profile: parsed.profile,
+        profileExplicit: parsed.profileExplicit,
+        taskIdOverride: parsed.taskIdOverride,
+        execute: parsed.execute,
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) {
+        process.exitCode = result.mode === "blocked" ? 2 : 1;
+    }
+}

package/dist/commands/dag-rerun.js

@@ -0,0 +1,111 @@
+import { executeDagRerun, planDagRerun, } from "../workflows/dag/rerun-run.js";
+export function parseDagRerunArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag rerun --run-id <id> --from-node <node-id> --plan [--json] | dag rerun --run-id <id> --from-node <node-id> --plan-hash <hash> --request-id <key> --reason <text> [--json]");
+    }
+    let parentRunId;
+    let selectedNodeId;
+    let planOnly = false;
+    let planHash;
+    let requestId;
+    let reason;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--run-id")
+            parentRunId = args[++index];
+        else if (arg.startsWith("--run-id="))
+            parentRunId = arg.slice("--run-id=".length);
+        else if (arg === "--from-node")
+            selectedNodeId = args[++index];
+        else if (arg.startsWith("--from-node="))
+            selectedNodeId = arg.slice("--from-node=".length);
+        else if (arg === "--plan")
+            planOnly = true;
+        else if (arg === "--plan-hash")
+            planHash = args[++index];
+        else if (arg.startsWith("--plan-hash="))
+            planHash = arg.slice("--plan-hash=".length);
+        else if (arg === "--request-id")
+            requestId = args[++index];
+        else if (arg.startsWith("--request-id="))
+            requestId = arg.slice("--request-id=".length);
+        else if (arg === "--reason")
+            reason = args[++index];
+        else if (arg.startsWith("--reason="))
+            reason = arg.slice("--reason=".length);
+        else if (arg === "--json")
+            continue;
+        else if (arg.startsWith("-"))
+            throw new Error(`unknown dag rerun flag: ${arg}`);
+        else
+            throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!parentRunId) {
+        throw new Error("dag rerun requires --run-id <id>");
+    }
+    if (!selectedNodeId) {
+        throw new Error("dag rerun requires --from-node <node-id>");
+    }
+    if (planOnly) {
+        if (planHash || requestId || reason) {
+            throw new Error("dag rerun --plan cannot be combined with execute flags");
+        }
+        return { parentRunId, selectedNodeId, planOnly: true };
+    }
+    if (!planHash?.trim()) {
+        throw new Error("dag rerun execute requires --plan-hash <hash>");
+    }
+    if (!requestId?.trim()) {
+        throw new Error("dag rerun execute requires --request-id <key>");
+    }
+    if (!reason?.trim()) {
+        throw new Error("dag rerun execute requires --reason <text>");
+    }
+    return {
+        parentRunId,
+        selectedNodeId,
+        planOnly: false,
+        planHash: planHash.trim(),
+        requestId: requestId.trim(),
+        reason: reason.trim(),
+    };
+}
+export async function runDagRerun(repoRoot, rawArgs) {
+    const parsed = parseDagRerunArgs(rawArgs);
+    if (parsed.planOnly) {
+        const plan = await planDagRerun({
+            cwd: repoRoot,
+            parentRunId: parsed.parentRunId,
+            selectedNodeId: parsed.selectedNodeId,
+        });
+        const result = {
+            ok: plan.eligible,
+            plan,
+        };
+        console.log(JSON.stringify(result, null, 2));
+        if (!plan.eligible) {
+            process.exitCode = 2;
+        }
+        return;
+    }
+    const result = await executeDagRerun({
+        cwd: repoRoot,
+        parentRunId: parsed.parentRunId,
+        selectedNodeId: parsed.selectedNodeId,
+        planHash: parsed.planHash,
+        requestId: parsed.requestId,
+        reason: parsed.reason,
+    });
+    console.log(JSON.stringify(result, null, 2));
+    if (!result.ok) {
+        if (result.errorCode === "PLAN_DRIFT") {
+            process.exitCode = 3;
+        }
+        else if (result.errorCode === "INELIGIBLE") {
+            process.exitCode = 2;
+        }
+        else {
+            process.exitCode = 1;
+        }
+    }
+}

package/dist/shared/operator/capabilities.js

@@ -167,6 +167,16 @@ export function buildOperatorCapabilitiesDocument() {
             requiredErrorCodes: ["INVALID_INPUT", "OPERATION_NEEDS_RECONCILE"],
             description: "Repo doctor (registry entry; envelope migration follow-up).",
         },
+        {
+            action: "dagReport",
+            cli: "loop-agent dag report --run-id <runId> --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "DAG run handoff report by run id.",
+        },
         {
             action: "status",
             cli: "loop-agent status <taskId> --json",
@@ -226,6 +236,50 @@ export function buildOperatorCapabilitiesDocument() {
             ],
             description: "Execute reviewed DAG; revalidate binding before writer start.",
         },
+        {
+            action: "dagRerunPlan",
+            cli: "loop-agent dag rerun --run-id <id> --from-node <node> --plan --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
+            description: "Read-only subgraph rerun plan for confirmation (no mutation).",
+        },
+        {
+            action: "dagRerun",
+            cli: "loop-agent dag rerun --run-id <id> --from-node <node> --plan-hash <hash> --request-id <id> --reason <text> --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [
+                ...COMMON_MUTATION_ERRORS,
+                "BINDING_DRIFT",
+                "INVALID_INPUT",
+            ],
+            description: "Execute continuation run from effective node with confirmed plan hash.",
+        },
+        {
+            action: "standaloneTaskRerun",
+            cli: "loop-agent dag rerun-task --run-id <id> --reason <text> --request-id <id> [--profile auto] [--task-id <id>] --json",
+            kind: "long-running",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [...COMMON_MUTATION_ERRORS, "INVALID_INPUT"],
+            description: "Full standalone task regenerate → validate → execute with parent lineage.",
+        },
+        {
+            action: "workerTaskRetry",
+            cli: "agent-worker task retry <task-id> --feature-id <feature-id> --repo . --reason <text>",
+            kind: "mutation",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: [...COMMON_MUTATION_ERRORS, "INVALID_INPUT"],
+            description: "Requeue failed Task Pool task (Failed → Ready) via in-package pool store.",
+        },
     ];
     return {
         schemaVersion: 1,

package/dist/worker/console/index.js

@@ -5,7 +5,7 @@ export { isLoopbackHost } from "./loopback.js";
 export { repoFingerprintV1, normalizeWorktreeRealpath, } from "./repo-fingerprint.js";
 export { buildObserveDeepLink } from "./observe-link.js";
 export { classifyObserveHealth, probeAndClassifyObserve, capabilityForObserveTarget, OBSERVE_START_COMMAND, DEFAULT_OBSERVE_BASE_URL, } from "./observe-health-match.js";
-export { allowedRecoveryCtas, classifyRecoveryFact, recoveryMatrixInvariants, } from "./recovery-cta.js";
+export { allowedRecoveryCtas, classifyRecoveryFact, partitionRecoveryCtas, recoveryMatrixInvariants, } from "./recovery-cta.js";
 export { createClosedResourceLoader, createInterviewResourceLoader, tryActivateTool, assertOfficialToolAllowed, listOfficialTools, OFFICIAL_DENIED_TOOL_IDS, INTERVIEW_ALLOWED_TOOLS, INTERVIEW_DENIED_TOOLS, authorizeInterviewTool, } from "./resource-loader.js";
 export { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
 export { openConsoleAppData, defaultConsoleAppDataRoot } from "./app-data.js";

package/dist/worker/console/inspect-split.js

@@ -0,0 +1,82 @@
+function asDisplayText(value) {
+    if (value == null)
+        return null;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed || null;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (typeof value === "object") {
+        const record = value;
+        if (typeof record.text === "string" && record.text.trim()) {
+            return record.text.trim();
+        }
+        if (typeof record.errorMessage === "string" && record.errorMessage.trim()) {
+            return record.errorMessage.trim();
+        }
+        if (Array.isArray(record.content)) {
+            const parts = record.content
+                .map((part) => {
+                if (typeof part === "string")
+                    return part;
+                if (part && typeof part === "object") {
+                    const item = part;
+                    if (typeof item.text === "string")
+                        return item.text;
+                }
+                return "";
+            })
+                .filter(Boolean);
+            if (parts.length)
+                return parts.join("\n").slice(0, 240);
+        }
+        if (typeof record.role === "string") {
+            return `${record.role} 消息`;
+        }
+    }
+    return null;
+}
+export function formatInspectTimelineEvent(event) {
+    const time = asDisplayText(event.at) ??
+        asDisplayText(event.timestamp) ??
+        asDisplayText(event.recordedAt) ??
+        "";
+    const text = asDisplayText(event.errorMessage) ??
+        asDisplayText(event.label) ??
+        asDisplayText(event.type) ??
+        asDisplayText(event.message) ??
+        "运行事件";
+    return time ? `${time} · ${text}` : text;
+}
+export function dagNodeKey(node) {
+    return String(node.nodeId ?? node.id ?? "").trim();
+}
+export function dagNodeLabel(node) {
+    const key = dagNodeKey(node);
+    return String(node.label ?? node.name ?? (key || "未命名节点"));
+}
+export function pickInspectNode(nodes, preferredNodeId) {
+    if (nodes.length === 0)
+        return undefined;
+    const preferred = preferredNodeId?.trim();
+    if (preferred) {
+        const match = nodes.find((node) => dagNodeKey(node) === preferred);
+        if (match)
+            return match;
+    }
+    const failed = nodes.find((node) => {
+        const status = String(node.status ?? "").toLowerCase();
+        return (status.includes("fail") ||
+            status.includes("error") ||
+            status === "blocked");
+    });
+    if (failed)
+        return failed;
+    const running = nodes.find((node) => {
+        const status = String(node.status ?? "").toLowerCase();
+        return status === "running" || status === "in_progress" || status === "active";
+    });
+    return running ?? nodes[0];
+}

package/dist/worker/console/operation-runner.js

@@ -30,7 +30,9 @@ export async function runOperation(operationId, deps) {
     });
     stateEvent(deps.events, op, "starting", "spawning sibling loop-agent");
     const run = deps.runCommand ??
-        ((cliArgs, options) => deps.client.run(cliArgs, options));
+        ((cliArgs, options) => op.externalCommand
+            ? deps.client.runExternal(op.externalCommand, cliArgs, options)
+            : deps.client.run(cliArgs, options));
     let finished;
     try {
         const result = await run(args, {

package/dist/worker/console/operation-store.js

@@ -55,6 +55,7 @@ export class OperationStore {
             createdAt: now,
             taskId: input.taskId,
             cliArgs: input.cliArgs,
+            ...(input.externalCommand ? { externalCommand: input.externalCommand } : {}),
         };
         await writeSecureJson(operationFile(this.appData, operationId), operation);
         await writeSecureJson(indexPath, { operationId, payloadHash });