@tea-agent/loop-agent 0.40.0-next.2 → 0.40.0-next.3

package/dist/worker/observe/node-input.js

@@ -31,6 +31,7 @@ function unavailableBody(dagRunId, nodeId, reason, warnings = []) {
         summary: null,
         dependency: null,
         prompt: null,
+        promptCandidates: [],
         executorInput: null,
         boundaries: null,
         promptFingerprint: null,
@@ -139,7 +140,7 @@ function resolveModelHint(spec, task) {
     }
     return null;
 }
-function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings) {
+function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings) {
     const defaults = spec.defaults && typeof spec.defaults === "object"
         ? spec.defaults
         : undefined;
@@ -267,6 +268,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExt
             maxBytes: promptBody.maxBytes,
             source: promptSource,
         },
+        promptCandidates,
         executorInput: {
             kind,
             skills,
@@ -292,6 +294,89 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, piExt
         warnings,
     };
 }
+async function loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings) {
+    const stateResolved = resolveDagRunArtifact(repoRoot, dagRunId, ["state.json"]);
+    if (!stateResolved.ok)
+        return [];
+    let state;
+    try {
+        state = JSON.parse(await readFile(stateResolved.result.absolutePath, "utf-8"));
+    }
+    catch {
+        warnings.push("state.json could not be read for failed prompt candidates.");
+        return [];
+    }
+    const nodes = state.nodes && typeof state.nodes === "object" && !Array.isArray(state.nodes)
+        ? state.nodes
+        : null;
+    const node = nodes?.[nodeId] &&
+        typeof nodes[nodeId] === "object" &&
+        !Array.isArray(nodes[nodeId])
+        ? nodes[nodeId]
+        : null;
+    if (!node)
+        return [];
+    const failedAttempts = new Set();
+    if (Array.isArray(node.attempts)) {
+        for (const entry of node.attempts) {
+            if (!entry || typeof entry !== "object" || Array.isArray(entry))
+                continue;
+            const record = entry;
+            if (record.ok === false &&
+                typeof record.attempt === "number" &&
+                Number.isSafeInteger(record.attempt) &&
+                record.attempt > 0) {
+                failedAttempts.add(record.attempt);
+            }
+        }
+    }
+    if (node.status === "ERROR" &&
+        typeof node.currentAttempt === "number" &&
+        Number.isSafeInteger(node.currentAttempt) &&
+        node.currentAttempt > 0) {
+        failedAttempts.add(node.currentAttempt);
+    }
+    const candidates = [];
+    for (const attempt of [...failedAttempts].sort((a, b) => a - b)) {
+        const fileName = `prompt-candidate-attempt-${attempt}.json`;
+        const artifact = path.posix.join(nodeId, fileName);
+        const resolved = resolveDagRunArtifact(repoRoot, dagRunId, [nodeId, fileName]);
+        if (!resolved.ok) {
+            warnings.push(`Failed prompt candidate missing for attempt ${attempt}.`);
+            continue;
+        }
+        try {
+            const raw = JSON.parse(await readFile(resolved.result.absolutePath, "utf-8"));
+            if (raw.schemaVersion !== 1 ||
+                raw.attempt !== attempt ||
+                typeof raw.failureCategory !== "string" ||
+                typeof raw.prompt !== "string" ||
+                typeof raw.truncated !== "boolean" ||
+                typeof raw.maxBytes !== "number" ||
+                !Number.isSafeInteger(raw.maxBytes) ||
+                raw.maxBytes < 1 ||
+                raw.maxBytes > NODE_INPUT_PREVIEW_MAX_BYTES ||
+                typeof raw.sha256 !== "string" ||
+                !/^([a-f0-9]{64})$/.test(raw.sha256)) {
+                throw new Error("invalid candidate schema");
+            }
+            const prompt = truncatedField(raw.prompt, raw.maxBytes);
+            candidates.push({
+                attempt,
+                failureCategory: redactSecrets(raw.failureCategory),
+                prompt: prompt.text,
+                truncated: raw.truncated || prompt.truncated,
+                maxBytes: raw.maxBytes,
+                sha256Prefix: raw.sha256.slice(0, 12),
+                artifact,
+            });
+        }
+        catch {
+            warnings.push(`Failed prompt candidate is invalid for attempt ${attempt}.`);
+        }
+    }
+    return candidates;
+}
 /**
  * Load run-time Pi extension facts from <node>/pi-extensions.json (plan
  * 2026-08-22 R2). Returns null when the node declares no piExtensions
@@ -486,8 +571,9 @@ export async function buildDagNodeInput(repoRoot, dagRunId, nodeId) {
         ? task.piExtensions.filter((item) => typeof item === "string")
         : [];
     const piExtensionRunFacts = await loadPiExtensionRunFacts(repoRoot, dagRunId, nodeId, declaredPiExtensions, warnings);
+    const promptCandidates = await loadFailedPromptCandidates(repoRoot, dagRunId, nodeId, warnings);
     // Reject unknown nested leakage by projecting only through allowlist helpers.
-    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, warnings);
+    const body = projectTask(dagRunId, nodeId, runResolved.result.lifecycle, spec, task, fingerprint, piExtensionRunFacts, promptCandidates, warnings);
     // Defense-in-depth: ensure raw task never sneaks in.
     if ("task" in body) {
         return {

package/dist/worker/observe/routes.js

@@ -11,7 +11,11 @@ import { buildGlobalSnapshot, clampDagRunHistoryPageSize, clampTaskRunHistoryLim
 import { loadDagRunExecutionTrajectory } from "../observability/dag-execution-trajectory.js";
 import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 import { dagSourceBindingSchema } from "../../workflows/dag/types.js";
+import { getTaskPaths } from "../../task/runtime.js";
+import { classifyLedgerGate, computeLedgerInputDigest, LedgerParseError, parseLedgerJson, recoverLedgerInputContract, summarizeLedger, } from "../../task/source-prepare/ledger.js";
 import { getTaskPoolRoot } from "../pool/run-store.js";
+import { resolveDagRunArtifact, } from "./dag-run-artifacts.js";
+import { frontendPrewriteResultV1Schema } from "../../workflows/dag/frontend-prewrite-gate.js";
 import { isAllowedArtifactTextPath, resolveArtifactPath, resolveRepoFilePreview, toRepoRelativeArtifactPath, } from "./paths.js";
 import { extractSpecEvidence, extractSpecReadContent, } from "./spec-evidence.js";
 import { buildDagNodeInput } from "./node-input.js";
@@ -70,6 +74,15 @@ export const ROUTES = [
         pattern: /^\/api\/tasks\/([^/]+)\/runs$/,
         handler: handleTaskRuns,
     },
+    /**
+     * Read-only source fidelity ledger safe summary (AC-009 / AC-FIDELITY-009):
+     * 只返回计数/状态/failure code，不泄漏敏感原文。
+     */
+    {
+        method: "GET",
+        pattern: /^\/api\/tasks\/([^/]+)\/ledger$/,
+        handler: handleTaskLedger,
+    },
     {
         method: "GET",
         pattern: /^\/api\/tasks\/([^/]+)$/,
@@ -116,6 +129,16 @@ export const ROUTES = [
         pattern: /^\/api\/dag-runs\/([^/]+)\/nodes\/([^/]+)\/spec-evidence\/file$/,
         handler: handleDagNodeSpecEvidenceFile,
     },
+    // DAG run 专属只读 prewrite 结果（AC-006 / AC-BLOCK-006）：唯一读路径为
+    // run-owned contracts/frontend-prewrite-result.json（resolveDagRunArtifact 四类
+    // fail-closed），不扩大 isAllowedArtifactTextPath 通用 allowlist；响应以
+    // frontendPrewriteResultV1Schema（.strict()）解析，Inspector 不再做
+    // /api/artifacts 预览 → JSON.stringify → JSON.parse 双编码。
+    {
+        method: "GET",
+        pattern: /^\/api\/dag-runs\/([^/]+)\/prewrite-result$/,
+        handler: handleDagRunPrewriteResult,
+    },
     {
         method: "GET",
         pattern: /^\/api\/dag-runs\/([^/]+)$/,
@@ -448,6 +471,117 @@ async function handleTaskRuns(_req, res, match, ctx) {
     });
     sendJson(res, 200, page);
 }
+/**
+ * GET /api/tasks/:id/ledger — 只读 ledger 安全摘要。任务存在但无 ledger 时返回
+ * `{ present: false }`（空态，不伪造计数）；任务不存在返回 404；ledger 解析失败
+ * 返回带稳定 SOURCE_FIDELITY_* 错误码的 `{ present: false }`（AC-HARD-003：与
+ * parseLedgerJson 同一稳定码，不泄漏原文）。binding v2 标记 + ledgerSha256 +
+ * inputDigest 仅在真实 v2 绑定（非空 canonical requirement 集）时展示（AC-HARD-004：
+ * v1+optional 冒充 v2 不标记）；inputDigest 与当前权威源输入不一致时置 stale。
+ */
+async function handleTaskLedger(_req, res, match, ctx) {
+    const taskId = match.params.id;
+    if (!isSafeObservabilityIdentifier(taskId)) {
+        sendJson(res, 400, { error: "Invalid task identifier" });
+        return;
+    }
+    const taskPaths = getTaskPaths(ctx.repoRoot, taskId);
+    try {
+        await stat(taskPaths.taskDir);
+    }
+    catch {
+        sendJson(res, 404, { error: "Task not found" });
+        return;
+    }
+    const ledgerPath = path.join(taskPaths.sourceDir, "requirement-ledger.json");
+    let raw;
+    try {
+        raw = await readFile(ledgerPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            sendJson(res, 200, { present: false, taskId });
+            return;
+        }
+        sendJson(res, 200, {
+            present: false,
+            taskId,
+            error: "ledger-unreadable",
+        });
+        return;
+    }
+    let ledger;
+    try {
+        ledger = parseLedgerJson(raw);
+    }
+    catch (error) {
+        // AC-HARD-003：解析失败分支使用与 parseLedgerJson 相同的稳定 SOURCE_FIDELITY_*
+        // 错误码（结构化可消费），而非裸字符串/裸 Error。
+        const code = error instanceof LedgerParseError
+            ? error.code
+            : "SOURCE_FIDELITY_LEDGER_STALE";
+        sendJson(res, 200, {
+            present: false,
+            taskId,
+            error: code,
+        });
+        return;
+    }
+    const classification = classifyLedgerGate(ledger);
+    const summary = summarizeLedger(ledger, {
+        gateStatus: classification.ok ? "pass" : "fail",
+        failureCode: classification.ok ? null : classification.code,
+    });
+    // v2 binding 语义（AC-HARD-004）：仅在真实 v2 绑定（canonical requirement 非空，
+    // 具备 requirement→fragment 映射证据）时标记 bindingSchemaVersion=2 并透传
+    // ledgerSha256/inputDigest；空 canonical 的 ledger 是退化/伪造 v2，不标记。
+    const contract = recoverLedgerInputContract(ledger);
+    const realV2Binding = contract.canonicalRequirements.length > 0;
+    let stale = false;
+    if (realV2Binding) {
+        // 当前权威源输入：ledger.sourcePaths（repo-root relative POSIX）→ 当前字节；
+        // 缺失/清空的权威源视为 stale（fail-closed，与 init-hybrid 语义一致）。
+        const currentByPath = new Map();
+        for (const sourcePath of contract.sourcePaths) {
+            try {
+                currentByPath.set(sourcePath, await readFile(path.resolve(ctx.repoRoot, sourcePath), "utf8"));
+            }
+            catch {
+                // 权威源缺失：保持缺失，expectedInputDigest 不一致 → stale。
+            }
+        }
+        const expectedDigest = computeLedgerInputDigest({
+            sourceDocuments: contract.sourcePaths.map((sourcePath) => ({
+                path: sourcePath,
+                content: currentByPath.get(sourcePath) ?? "",
+            })),
+            canonicalRequirements: contract.canonicalRequirements,
+        });
+        stale = ledger.inputDigest !== expectedDigest;
+    }
+    const ledgerSha256 = createHash("sha256").update(raw).digest("hex");
+    sendJson(res, 200, {
+        present: true,
+        taskId,
+        ...(realV2Binding
+            ? {
+                bindingSchemaVersion: 2,
+                ledgerSha256,
+                inputDigest: ledger.inputDigest,
+                stale,
+            }
+            : {}),
+        fragmentCount: summary.fragmentCount,
+        canonicalRequirementCount: summary.canonicalRequirementCount,
+        contextOnlyCount: summary.contextOnlyCount,
+        duplicateCount: summary.duplicateCount,
+        unresolvedCount: summary.unresolvedCount,
+        conflictCount: summary.conflictCount,
+        gateStatus: summary.gateStatus,
+        failureCode: summary.failureCode,
+        exclusions: summary.exclusions,
+    });
+}
 function ambiguousTaskBody(taskId, candidates) {
     return {
         error: "Task identity ambiguous",
@@ -535,6 +669,60 @@ async function handleDagRuns(_req, res, match, ctx) {
     const body = listDagRunHistoryFromSnapshot(snapshot, { page, pageSize });
     sendJson(res, 200, body);
 }
+/**
+ * GET /api/dag-runs/:dagRunId/prewrite-result（AC-006 / AC-BLOCK-006）
+ * 只读 run-owned contracts/frontend-prewrite-result.json：resolveDagRunArtifact 是
+ * 唯一读路径（active/paused/completed 生命周期；invalid-id / unsafe-path /
+ * not-found / ambiguous 四类 fail-closed）。响应以 frontendPrewriteResultV1Schema
+ * （.strict()）解析，拒绝 envelope 之外的字段；不扩大通用 artifact allowlist。
+ */
+async function handleDagRunPrewriteResult(_req, res, match, ctx) {
+    const dagRunId = match.params.id;
+    const resolved = resolveDagRunArtifact(ctx.repoRoot, dagRunId, [
+        "contracts",
+        "frontend-prewrite-result.json",
+    ]);
+    if (!resolved.ok) {
+        if (resolved.reason === "invalid-id") {
+            sendJson(res, 400, { error: "Invalid dag run identifier" });
+            return;
+        }
+        if (resolved.reason === "ambiguous") {
+            sendJson(res, 409, { error: "DAG run identity ambiguous" });
+            return;
+        }
+        sendJson(res, 404, { error: "Prewrite result not found" });
+        return;
+    }
+    let raw;
+    try {
+        raw = await readFile(resolved.result.absolutePath, "utf8");
+    }
+    catch {
+        sendJson(res, 404, { error: "Prewrite result not found" });
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        sendJson(res, 500, {
+            error: "Prewrite result is not valid JSON",
+            reason: "prewrite-result-unparseable",
+        });
+        return;
+    }
+    const envelope = frontendPrewriteResultV1Schema.safeParse(parsed);
+    if (!envelope.success) {
+        sendJson(res, 500, {
+            error: "Prewrite result is not a valid frontend-prewrite-result-v1 envelope",
+            reason: "prewrite-result-schema-invalid",
+        });
+        return;
+    }
+    sendJson(res, 200, envelope.data);
+}
 export async function handleDagRunById(_req, res, match, ctx) {
     const snapshot = await getSnapshot(ctx);
     const dagRun = snapshot.dagRuns.find((d) => d.dagRunId === match.params.id);

package/dist/worker/observe/static/api.js

@@ -116,8 +116,9 @@ export function artifactUrl(artifactPath) {
  * Experimental (prompt-override rerun only): POST one allowlisted operator
  * action through the Console mutation gate using the SCOPED inspect token
  * (window.__INSPECT_MUTATION_TOKEN__). The server injects it into /inspect
- * HTML only when HARNESS_DAG_RERUN_PROMPT_OVERRIDE is enabled, and it only
- * authorizes dagRerunPlan / dagRerun — never general Console mutations.
+ * HTML by default; HARNESS_DAG_RERUN_PROMPT_OVERRIDE=0|false|off disables
+ * injection. The token only authorizes dagRerunPlan / dagRerun — never general
+ * Console mutations.
  * Absent token → the call is not attempted.
  */
 export async function postOperatorAction(action, actionParams = {}) {
@@ -180,4 +181,3 @@ export function parseArtifactPreviewResponse(text) {
 		truncated: parsed.truncated === true,
 	};
 }
-

package/dist/worker/observe/static/dag-node-purpose.d.ts

@@ -0,0 +1,6 @@
+export const NODE_PURPOSE_BY_ID: Record<string, string>;
+
+export function describeDagNodePurpose(
+	nodeId: string | null | undefined,
+	node?: { executor?: string | null; label?: string | null },
+): string;

package/dist/worker/observe/static/dag-node-purpose.js

@@ -0,0 +1,203 @@
+/**
+ * Short Chinese purpose copy for DAG node IDs shown in the inspector table.
+ * Exact IDs first; then conservative suffixes. Never echo the raw nodeId.
+ */
+
+const NODE_PURPOSE_BY_ID = {
+	"contract-pi": "只读梳理范围、风险与写入边界，产出实现契约，不改代码。",
+	"scout-src": "只读侦察源码结构与现有模式，给后续实现找落点，不改文件。",
+	"scout-tests": "只读侦察测试与验证入口，标出可复用的检查方式，不改文件。",
+	"plan-pi": "根据契约与侦察结果制定实现计划与 writeSet，仍不改业务代码。",
+	"plan-revision-pi": "按审查意见修订实现计划，收窄写入范围，不扩大任务边界。",
+	"implement-pi": "在允许路径内按计划改代码，完成本轮主实现。",
+	"implement-core": "在允许路径内完成核心实现，不越出约定写入范围。",
+	"repair-pi": "只修验证暴露出的可修复问题，不重开需求、不扩大 writeSet。",
+	"verify-shell": "跑冻结的验证命令，用退出码证明实现是否达标。",
+	"soft-verify-shell": "先做软验证，留下证据供过程监督，不立刻判整单失败。",
+	"hard-verify-shell": "硬验证：命令必须通过，作为后续审查与收口的事实。",
+	"review-pi": "对照需求与 diff 做只读审查，给出通过或需修订。",
+	"review-verdict-recovery-pi": "补齐或纠正审查结论格式，确保门禁能读到明确 VERDICT。",
+	"review-gate-shell": "确定性门禁：只有审查结论为通过才放行收口。",
+	"decision-pi": "汇总本轮证据，给出继续、修订或停止的决策建议。",
+	"closeout-pi": "汇总完成证据与交接说明，宣告本轮交付结束。",
+	"write-set-audit-pi": "审查计划中的写入范围是否过宽或重叠，给出初审结论。",
+	"write-set-audit-format-repair-pi": "只修复写入范围审查的结论格式，不改计划内容。",
+	"write-set-format-gate-shell": "检查写入范围审查格式是否有效，未通过则不能开始改代码。",
+	"final-write-set-audit-pi": "终审写入范围：确认最终计划可授权 implement-pi。",
+	"final-write-set-audit-format-repair-pi": "只修复终审结论格式，保留原审查发现。",
+	"write-set-gate-shell": "写入授权门禁：终审通过后才允许实现节点改文件。",
+	"process-supervisor-pi": "只读检查实现过程是否偏离契约与验证，提出Bounded 修复建议。",
+	"process-gate-shell": "过程监督门禁：根据监督结论决定是否进入 repair。",
+	"authority-surface-audit-pi": "审查谁能写状态、哪些面暴露给模型，防止越权通路。",
+	"authority-surface-gate-shell": "权限面门禁：审查未通过则不能进入收口。",
+	"task-state-reconcile-shell": "核对任务状态与运行事实是否一致，避免用过期状态收口。",
+	"requirement-coverage-shell": "检查实现是否覆盖已编号需求，漏项则不能宣称完成。",
+	"static-invariant-shell": "跑静态不变量检查，确认约定结构与约束仍成立。",
+	"changeset-impact-shell": "评估本轮 diff 的影响面，标出高风险改动。",
+	"closeout-artifact-shell": "收集收口所需的确定性产物与证据路径。",
+	"final-verify-shell": "收口前最后一轮冻结验证，作为完成权威。",
+	"closeout-summary-pi": "把验证与交付事实写成简短交接摘要。",
+
+	"frontend-contract-pi": "把前端需求整理成可追踪契约：页面、状态、验收与边界。",
+	"frontend-scout-pi": "只读侦察前端结构、组件与接口用法，不改文件。",
+	"frontend-plan-pi": "选定实现与 Mock/API 策略，输出可执行的前端实现契约补丁。",
+	"frontend-design-review-pi": "审查前端计划是否可写：通过则沿用原计划，否则要求修订。",
+	"frontend-plan-revision-pi": "按设计审查意见修订前端契约，不扩大范围。",
+	"frontend-final-design-review-pi": "复核修订后的前端计划，只有通过才能授权写入。",
+	"frontend-prewrite-gate-shell": "写入前门禁：核对契约、覆盖与 Mock 策略，通过才允许改前端。",
+	"frontend-lint-baseline-shell": "记录写入前的 lint 基线，供实现后对比，不阻断写入。",
+	"frontend-implement-pi": "按已批准契约改前端代码、状态与交互，留在 writeSet 内。",
+	"frontend-verify-assess-shell": "跑静态/行为/Mock 验证并评估能否有界修复。",
+	"frontend-repair-pi": "只修评估为可修复的前端失败，不重开需求。",
+	"frontend-reverify-shell": "修复后用同一套冻结命令复验。",
+	"frontend-review-context-shell": "打包真实 diff 与有效验证证据，供审查节点使用。",
+	"frontend-review-pi": "对照契约审查前端实现与证据，给出通过或需修订。",
+	"frontend-review-gate-shell": "前端审查门禁：结论为通过才进入收口。",
+	"frontend-closeout-pi": "汇总前端交付状态（含真实联调是否仍待完成）。",
+	"frontend-mock-assess-pi": "评估项目是否具备授权的 Mock 验证能力。",
+	"frontend-mock-contract-gate-shell": "Mock 契约门禁：策略与验证命令不一致则阻断。",
+	"frontend-mock-verify-shell": "执行已授权的 Mock 验证命令。",
+	"frontend-mock-blocked-shell": "缺少授权 Mock 命令时给出确定性阻断说明。",
+
+	"preflight-frontend-browser-tool-shell": "检查浏览器自动化工具是否可用，失败则不进入用例执行。",
+	"prepare-frontend-test-package-shell": "准备前端测试包与标准场景资产。",
+	"retrieve-frontend-test-context-pi": "检索页面与验收上下文，供生成用例引用。",
+	"materialize-frontend-test-execution-shell": "物化前端测试执行清单与路径。",
+	"generate-frontend-functional-cases-pi": "按验收标准生成可执行的前端功能用例。",
+	"checklist-and-materialize-manifest-shell": "核对清单并物化用例 manifest。",
+	"execute-frontend-cases-map": "按用例清单并行跑浏览器步骤，每条用例一个子节点。",
+	"select-frontend-rerun-candidates-shell": "挑出可有界重跑的失败/缺失用例。",
+	"rerun-frontend-cases-map": "对入选用例再跑一轮浏览器步骤，以最新证据为准。",
+	"generate-backend-md-cases-map": "按模块并行写出 Markdown 用例卡片。",
+	"generate-backend-pytest-cases-map": "按模块并行写出对应的 pytest 脚本。",
+	"patch-backend-md-cases-map": "按缺口计划并行补丁各模块 Markdown 用例。",
+	"patch-backend-pytest-cases-map": "按缺口计划并行补丁各模块 pytest 脚本。",
+	"finalize-frontend-test-result-shell": "汇总用例结果，写成统一结论。",
+	"frontend-test-reports-shell": "生成前端测试 HTML/Markdown 报告。",
+	"frontend-test-result-outcome-gate-shell": "前端测试结果门禁：未达标则不能进入复盘收口。",
+	"frontend-test-retrospect-pi": "根据真实执行证据写前端测试复盘。",
+
+	"validate-backend-test-environment-shell": "检查 Python/pytest 与测试布局是否可跑，失败则不消耗模型。",
+	"backend-test-analysis-contract-shell": "固化后端测试分析契约与布局。",
+	"backend-test-environment-scout-pi": "侦察后端测试环境与入口，不改业务代码。",
+	"backend-test-execution-contract-shell": "冻结后端测试如何执行、产物写到哪里。",
+	"generate-backend-md-plan-pi": "生成中文模块索引与用例卡片计划。",
+	"materialize-backend-md-module-manifest-shell": "把 Markdown 模块清单落到磁盘。",
+	"review-and-revise-backend-md-cases-pi": "独立审查并修订 Markdown 用例。",
+	"validate-backend-md-cases-shell": "校验用例章节与 Case ID，结果只记录不阻断。",
+	"generate-backend-pytest-plan-pi": "把 Markdown 用例转成 pytest 脚本计划。",
+	"materialize-backend-pytest-module-manifest-shell": "物化 pytest 模块与脚本映射。",
+	"assess-backend-pytest-collection-shell": "试收集 pytest：能修的缺口才进入 repair。",
+	"repair-backend-pytest-collection-pi": "只补齐可归因的缺失 mapped 脚本。",
+	"effective-backend-pytest-collection-gate-shell": "收集门禁：映射不齐则不跑业务 pytest。",
+	"backend-test-traceability-gate-shell": "核对用例、脚本与验收的追踪关系。",
+	"backend-test-case-manifest-shell": "写出本轮有效用例清单事实。",
+	"execute-backend-pytest-and-html-report-shell": "单次跑业务 pytest 并生成 HTML/事实报告。",
+	"backend-test-report-and-l5-pi": "用中文汇总 advisory、执行事实与结论。",
+	"backend-test-outcome-gate-shell": "后端测试结果门禁：失败分类决定能否收口。",
+	"backend-test-report-shell": "生成后端测试报告产物。",
+
+	"knowledge-sync-collect-pi": "收集本轮验证与实现中应回写的知识。",
+	"knowledge-sync-draft-pi": "起草知识条目，不直接改权威文档。",
+	"knowledge-sync-validate-shell": "校验知识草稿结构与路径边界。",
+	"knowledge-sync-apply-pi": "把通过校验的知识写入约定文档。",
+	"knowledge-sync-pointer-pi": "更新知识索引或指针，方便下次检索。",
+
+	"kg-bootstrap-preflight-shell": "图谱开荒前检：确认仓库与工具可用。",
+	"kg-bootstrap-inventory-shell": "盘点代码与文档，列出待建图谱对象。",
+	"kg-bootstrap-propose-pi": "提出知识图谱节点与关系草案。",
+	"kg-bootstrap-validate-shell": "校验图谱草案是否可物化。",
+	"kg-bootstrap-review-pi": "审查图谱草案质量与边界。",
+	"kg-bootstrap-review-gate-shell": "图谱审查门禁：通过才允许物化。",
+	"kg-bootstrap-promote-shell": "把审查通过的图谱草案提升为有效输入。",
+	"kg-bootstrap-materialize-shell": "把图谱写入约定产物路径。",
+};
+
+function normalizeNodeId(nodeId) {
+	return String(nodeId ?? "")
+		.trim()
+		.split(/[/#]/)[0];
+}
+
+const NODE_PURPOSE_BY_PREFIX = [
+	[/^execute-frontend-case-\d+$/, "执行单条前端用例的浏览器步骤，并留下证据。"],
+	[/^rerun-frontend-case-/, "重跑入选的前端用例，以本轮证据覆盖上一轮结果。"],
+	[/^generate-backend-md-case-/, "为单个后端模块写出 Markdown 用例卡片。"],
+	[/^generate-backend-pytest-case-/, "为单个后端模块写出对应的 pytest 脚本。"],
+	[/^patch-backend-md-case-/, "按缺口计划补丁单个模块的 Markdown 用例。"],
+	[/^patch-backend-pytest-case-/, "按缺口计划补丁单个模块的 pytest 脚本。"],
+];
+
+function describeFromPattern(nodeId) {
+	const id = nodeId.toLowerCase();
+	for (const [pattern, text] of NODE_PURPOSE_BY_PREFIX) {
+		if (pattern.test(id)) return text;
+	}
+	if (id.endsWith("-map") || id.includes("-cases-map")) {
+		return "按清单并行展开子节点并汇总结果。";
+	}
+	if (id.includes("-gate-shell")) {
+		return "确定性门禁：核验上游结论，通过才放行后续节点。";
+	}
+	if (id.endsWith("-shell") && id.includes("verify")) {
+		return "跑冻结验证命令，留下可复查的通过/失败证据。";
+	}
+	if (id.endsWith("-shell") && (id.includes("report") || id.includes("manifest"))) {
+		return "把本轮证据整理成报告或清单，不改业务代码。";
+	}
+	if (id.endsWith("-shell")) {
+		return "运行确定性命令并留下证据，不靠模型自由发挥。";
+	}
+	if (id.includes("scout") && id.endsWith("-pi")) {
+		return "只读侦察相关代码或测试，整理给下游使用，不改文件。";
+	}
+	if (id.includes("repair") && id.endsWith("-pi")) {
+		return "在原写入范围内做有界修复，不重开需求。";
+	}
+	if (id.includes("implement") && id.endsWith("-pi")) {
+		return "在允许路径内改代码，完成本节点负责的实现。";
+	}
+	if ((id.includes("review") || id.includes("audit")) && id.endsWith("-pi")) {
+		return "只读审查上游产出，给出通过或需修订的结论。";
+	}
+	if (id.includes("plan") && id.endsWith("-pi")) {
+		return "制定或修订计划/契约，仍不直接改业务代码。";
+	}
+	if (id.includes("closeout") && id.endsWith("-pi")) {
+		return "汇总证据并写出交接说明。";
+	}
+	if (id.includes("contract") && id.endsWith("-pi")) {
+		return "把需求收成可执行契约：范围、验收与边界。";
+	}
+	if (id.endsWith("-pi")) {
+		return "由模型完成该步骤的分析或写入，受 writeSet 与验证约束。";
+	}
+	return "";
+}
+
+function describeFromExecutor(executor) {
+	if (executor === "shell") return "运行确定性命令并留下证据。";
+	if (executor === "pi") return "由模型执行该步骤，范围受节点契约约束。";
+	if (executor === "static") return "按冻结规则直接给出结果，不调用模型。";
+	return "";
+}
+
+/**
+ * @param {string | null | undefined} nodeId
+ * @param {{ executor?: string | null, label?: string | null }} [node]
+ */
+export function describeDagNodePurpose(nodeId, node = {}) {
+	const id = normalizeNodeId(nodeId);
+	if (!id) return "";
+	const exact = NODE_PURPOSE_BY_ID[id];
+	if (exact) return exact;
+	const patterned = describeFromPattern(id);
+	if (patterned) return patterned;
+	const label = typeof node.label === "string" ? node.label.trim() : "";
+	if (label && label !== id && label.toLowerCase() !== id.toLowerCase()) {
+		return label;
+	}
+	return describeFromExecutor(node.executor) || "";
+}
+
+export { NODE_PURPOSE_BY_ID };

package/dist/worker/observe/static/format.js

@@ -368,3 +368,40 @@ export function prettyJsonBlock(text) {
 		return null;
 	}
 }
+
+/**
+ * Source fidelity ledger 安全摘要渲染（AC-009/AC-010/AC-HARD-004）：计数/状态/
+ * failure code + v2 binding 语义（binding=v2 + ledger sha256/inputDigest，仅真实
+ * DagSourceBindingV2 时展示；inputDigest ≠ 当前 expectedInputDigest 时标记 stale）+
+ * 有界排除理由（fragmentId + 截断 reason），绝不渲染未截断原文。输入即安全摘要对象。
+ */
+export function formatLedgerSummary(summary) {
+	if (!summary || summary.present !== true) {
+		return "无 source fidelity ledger（任务无引用或 ledger 缺失，不伪造计数）";
+	}
+	const lines = [
+		`fragments=${summary.fragmentCount ?? 0}`,
+		`canonical requirements=${summary.canonicalRequirementCount ?? 0}`,
+		`context-only=${summary.contextOnlyCount ?? 0}`,
+		`duplicate=${summary.duplicateCount ?? 0}`,
+		`unresolved=${summary.unresolvedCount ?? 0}`,
+		`conflict=${summary.conflictCount ?? 0}`,
+		`gate=${summary.gateStatus ?? "unknown"}`,
+	];
+	if (summary.bindingSchemaVersion === 2) {
+		lines.push(
+			`binding=v2（受管 ledger 绑定）${summary.stale ? " · STALE（输入漂移）" : ""}`,
+		);
+		if (summary.ledgerSha256) lines.push(`ledgerSha256=${summary.ledgerSha256}`);
+		if (summary.inputDigest) lines.push(`inputDigest=${summary.inputDigest}`);
+	}
+	if (summary.failureCode) lines.push(`failureCode=${summary.failureCode}`);
+	const exclusions = Array.isArray(summary.exclusions) ? summary.exclusions : [];
+	if (exclusions.length > 0) {
+		lines.push("排除理由（有界摘要）：");
+		for (const entry of exclusions.slice(0, 20)) {
+			lines.push(`- ${entry.fragmentId}: ${truncateText(entry.reason ?? "", 120)}`);
+		}
+	}
+	return lines.join("\n");
+}

package/dist/worker/observe/static/index.html

@@ -352,6 +352,11 @@
             class="panel panel-table"
             aria-label="运行历史"
           ></section>
+          <section
+            id="task-ledger"
+            class="panel panel-table"
+            aria-label="Source fidelity ledger"
+          ></section>
         </section>
 
         <section data-view="feature" id="view-feature" class="view" hidden>

package/dist/worker/observe/static/prompt-restart-candidates.d.ts

@@ -0,0 +1,18 @@
+export type PromptRestartFailedCandidate = {
+	attempt?: number;
+	failureCategory?: string;
+	prompt?: string;
+	truncated?: boolean;
+};
+
+export type PromptRestartCandidateOption = {
+	key: string;
+	label: string;
+	prompt: string;
+	truncated: boolean;
+};
+
+export function buildPromptRestartCandidateOptions(
+	frozenPrompt: string | null | undefined,
+	failedCandidates: PromptRestartFailedCandidate[] | null | undefined,
+): PromptRestartCandidateOption[];