@tea-agent/loop-agent 0.39.0 → 0.39.1

package/dist/workflows/dag/frontend-prewrite-gate.js

@@ -2,9 +2,12 @@ import { createHash } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
+import { isDagSourceBindingV2 } from "./types.js";
 import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
 import { writeTextArtifactFile } from "../../infrastructure/harness/artifact-store.js";
 import { countExcludedGovernanceSpecFiles, resolveOpenspecGovernanceRoot, } from "../../task/frontend-project-capability.js";
+import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
+import { parseLedgerJson, validateRequirementLedger, } from "../../task/source-prepare/ledger.js";
 import { analyzeFrontendImplementationContract, writeFrontendImplementationContractArtifact, writeDeterministicJsonArtifact, assertFrontendSourceBindingFresh, deterministicSha256, sha256Hex, serializeDeterministicJson, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, FrontendContractFailure, frontendNormalizationActionSchema, } from "./frontend-implementation-contract.js";
 import { renderFrontendPlanMarkdown } from "./frontend-plan-render.js";
 import { captureFrontendWorktreeBaseline } from "./frontend-worktree-diff.js";
@@ -42,6 +45,14 @@ export const frontendPrewriteFailureCodeSchema = z.enum([
     "component-choices-missing",
     "contract-too-large",
     "revision-patch-unmergeable",
+    // Source fidelity ledger 类目（SOURCE_FIDELITY_*/source-* 稳定错误码）。
+    "source-fidelity-ledger-missing",
+    "source-fidelity-ledger-stale",
+    "source-fidelity-unresolved",
+    "source-fidelity-conflict",
+    "source-fidelity-high-risk-uncovered",
+    "source-fidelity-requirement-not-covered",
+    "source-fidelity-source-ref-invalid",
 ]);
 export const frontendPrewriteResultV1Schema = z
     .object({
@@ -442,6 +453,162 @@ async function finalizePrewrite(input, pending) {
         openspecPolicy: pending.openspecPolicy,
     };
 }
+/**
+ * Source fidelity ledger 门禁检查（AC-FIDELITY-002/003/006）：绑定携带 ledger 指针时，
+ * 依次核验 ledger 存在、绑定 hash 一致、inputDigest 新鲜、无 unresolved/conflict/
+ * 高风险未覆盖、canonical requirement 全覆盖、来源引用有效且非伪造。任一失败 fail closed。
+ */
+export async function checkFrontendSourceFidelityLedger(input) {
+    const { binding } = input;
+    // v1 绑定不携带 ledger 指针：非 frontend task / 无可解析引用 → 无 v2 校验路径。
+    if (!isDagSourceBindingV2(binding)) {
+        return { ok: true, failureCode: null, failureReason: null, ledger: null };
+    }
+    const absolute = resolveDagTaskSourcePath({
+        workspaceRoot: input.workspaceRoot,
+        taskId: binding.taskId,
+        sourcePath: binding.ledgerPath,
+    });
+    let raw;
+    try {
+        raw = await readFile(absolute, "utf8");
+    }
+    catch (error) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-ledger-missing",
+            failureReason: `frontend source fidelity ledger missing: ${binding.ledgerPath} (${error instanceof Error ? error.message : String(error)})`,
+            ledger: null,
+        };
+    }
+    const actualSha = createHash("sha256").update(raw).digest("hex");
+    if (actualSha !== binding.ledgerSha256) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-ledger-stale",
+            failureReason: `frontend source fidelity ledger stale or tampered: ${binding.ledgerPath} (bound ${binding.ledgerSha256}, observed ${actualSha})`,
+            ledger: null,
+        };
+    }
+    let ledger;
+    try {
+        ledger = parseLedgerJson(raw);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-ledger-stale",
+            failureReason: `frontend source fidelity ledger is not a valid v1 ledger: ${error instanceof Error ? error.message : String(error)}`,
+            ledger: null,
+        };
+    }
+    if (ledger.inputDigest !== binding.inputDigest) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-ledger-stale",
+            failureReason: `frontend source fidelity ledger inputDigest mismatch: bound ${binding.inputDigest}, ledger ${ledger.inputDigest}`,
+            ledger,
+        };
+    }
+    const validation = validateRequirementLedger(ledger);
+    const firstError = (code) => validation.find((error) => error.code === code)?.message ?? null;
+    if (ledger.stats.unresolvedCount > 0 || validation.some((e) => e.code === "SOURCE_FIDELITY_UNRESOLVED")) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-unresolved",
+            failureReason: firstError("SOURCE_FIDELITY_UNRESOLVED") ??
+                `frontend source fidelity ledger has ${ledger.stats.unresolvedCount} unresolved fragment(s)`,
+            ledger,
+        };
+    }
+    if (ledger.stats.conflictCount > 0 || validation.some((e) => e.code === "SOURCE_FIDELITY_CONFLICT")) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-conflict",
+            failureReason: firstError("SOURCE_FIDELITY_CONFLICT") ??
+                `frontend source fidelity ledger has ${ledger.stats.conflictCount} conflict(s)`,
+            ledger,
+        };
+    }
+    if (ledger.stats.highRiskUncoveredCount > 0 ||
+        validation.some((e) => e.code === "SOURCE_FIDELITY_HIGH_RISK_UNCOVERED")) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-high-risk-uncovered",
+            failureReason: firstError("SOURCE_FIDELITY_HIGH_RISK_UNCOVERED") ??
+                `frontend source fidelity ledger has ${ledger.stats.highRiskUncoveredCount} high-risk uncovered fragment(s)`,
+            ledger,
+        };
+    }
+    // AC-BLOCK-001：canonical requirement 缺少 fragment/sourceRef 证据（ledger 侧
+    // REQUIREMENT_NOT_COVERED）与来源引用/片段无效（SOURCE_REF_INVALID /
+    // FRAGMENT_INVALID）均为阻断性失败，结构化失败结果不得产生可继续执行的成功。
+    const notCoveredError = validation.find((e) => e.code === "SOURCE_FIDELITY_REQUIREMENT_NOT_COVERED");
+    if (notCoveredError) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-requirement-not-covered",
+            failureReason: notCoveredError.message,
+            ledger,
+        };
+    }
+    const refInvalidError = validation.find((e) => e.code === "SOURCE_FIDELITY_SOURCE_REF_INVALID" ||
+        e.code === "SOURCE_FIDELITY_FRAGMENT_INVALID");
+    if (refInvalidError) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-source-ref-invalid",
+            failureReason: refInvalidError.message,
+            ledger,
+        };
+    }
+    const ledgerIds = new Set(ledger.canonicalRequirements.map((requirement) => requirement.id));
+    const contractIds = new Set(input.contractRequirements.map((r) => r.id));
+    const uncoveredRequirements = [...ledgerIds].filter((id) => !contractIds.has(id));
+    if (uncoveredRequirements.length > 0) {
+        return {
+            ok: false,
+            failureCode: "source-fidelity-requirement-not-covered",
+            failureReason: `frontend contract requirements do not cover ledger canonical requirement ids: ${uncoveredRequirements.join(", ")}`,
+            ledger,
+        };
+    }
+    const fragmentById = new Map(ledger.fragments.map((fragment) => [fragment.id, fragment]));
+    for (const requirement of input.contractRequirements) {
+        if (!ledgerIds.has(requirement.id))
+            continue;
+        const declared = requirement.sourceFragmentIds ?? [];
+        if (declared.length === 0) {
+            return {
+                ok: false,
+                failureCode: "source-fidelity-source-ref-invalid",
+                failureReason: `frontend contract requirement ${requirement.id} lacks sourceFragmentIds for the bound ledger`,
+                ledger,
+            };
+        }
+        const boundFragments = new Set(ledger.canonicalRequirements.find((r) => r.id === requirement.id)
+            ?.sourceFragmentIds ?? []);
+        for (const fragmentId of declared) {
+            if (!fragmentById.has(fragmentId)) {
+                return {
+                    ok: false,
+                    failureCode: "source-fidelity-source-ref-invalid",
+                    failureReason: `frontend contract requirement ${requirement.id} references unknown fragment ${fragmentId}`,
+                    ledger,
+                };
+            }
+            if (!boundFragments.has(fragmentId)) {
+                return {
+                    ok: false,
+                    failureCode: "source-fidelity-source-ref-invalid",
+                    failureReason: `frontend contract requirement ${requirement.id} declares fabricated fragment reference ${fragmentId} (not bound in ledger)`,
+                    ledger,
+                };
+            }
+        }
+    }
+    return { ok: true, failureCode: null, failureReason: null, ledger };
+}
 export async function runFrontendPrewriteGate(input) {
     const workspaceRoot = input.workspaceRoot ?? input.repoRoot;
     // selectNode throws for a scheduling defect (no FINISHED plan/review). That
@@ -589,6 +756,33 @@ export async function runFrontendPrewriteGate(input) {
         }
         throw error;
     }
+    // Source fidelity ledger gate (20260824-frontend-source-fidelity-ledger-v1):
+    // 在 verdict/missing-requirement-ids/source-binding-not-fresh 之后插入 ledger
+    // 检查。缺失即 fail closed 且 writer 不获授权；所有检查通过才继续物化契约。
+    if (input.sourceBinding) {
+        const ledgerCheck = await checkFrontendSourceFidelityLedger({
+            workspaceRoot: workspaceRoot ?? "",
+            binding: input.sourceBinding,
+            contractRequirements: analysis.canonical.requirements.map((requirement) => ({
+                id: requirement.id,
+                sourceFragmentIds: requirement.sourceFragmentIds,
+                sourceRefs: requirement.sourceRefs,
+            })),
+        });
+        if (!ledgerCheck.ok && ledgerCheck.failureCode) {
+            return finalizePrewrite(input, {
+                ...basePending,
+                verdict,
+                candidateJsonSha256: analysis.candidateJsonSha256,
+                normalizationActions: [],
+                mockStrategy: analysis.canonical.mockApi.strategy,
+                classification: "blocked",
+                failureReason: ledgerCheck.failureReason ??
+                    "frontend source fidelity ledger gate failed",
+                failureCode: ledgerCheck.failureCode,
+            });
+        }
+    }
     // Size guard: a canonical contract above 64KB is a retryable-invalid defect
     // (compress the contract) rather than a writer authorization failure.
     const contractSizeBytes = Buffer.byteLength(serializeDeterministicJson(analysis.canonical), "utf8");
@@ -947,6 +1141,9 @@ export function formatFrontendPrewriteGateStdout(result) {
     }
     lines.push(`Prewrite result: ${result.prewriteResult.path}`);
     lines.push(`Openspec policy: ${result.openspecPolicy}`);
+    if (result.failureCode?.startsWith("source-fidelity-")) {
+        lines.push(`Source fidelity ledger: blocked (${result.failureCode})`);
+    }
     if (result.failureReason)
         lines.push(`Failure reason: ${result.failureReason}`);
     if (result.openspecReadPaths.length > 0) {

package/dist/workflows/dag/frontend-review-context.js

@@ -1,17 +1,39 @@
+import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { formatFrontendWorktreeDiffStdout, runFrontendWorktreeDiffGate, } from "./frontend-worktree-diff.js";
 import { frontendLintAssessmentArtifactSchema } from "./frontend-lint-baseline.js";
-import { frontendImplementationContractSchema } from "./frontend-implementation-contract.js";
+import { frontendImplementationContractSchema, } from "./frontend-implementation-contract.js";
 import { frontendRepairAssessmentSchema } from "./frontend-repair.js";
+import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
+import { ledgerStatsLine, parseLedgerJson, } from "../../task/source-prepare/ledger.js";
 export const FRONTEND_REVIEW_CONTEXT_SCHEMA_ID = "frontend-review-context-v1";
+/**
+ * review-context 稳定失败枚举（AC-011 / AC-HARD-005）：v2 drift / manifest 失败返回
+ * 结构化、可消费的 failure code（稳定枚举 + reason 的 envelope），既有调用方无需字符串
+ * 匹配裸 Error 文本。message 保持人类可读（shell stderr 兼容），code 供机械化路由。
+ */
+export const FRONTEND_REVIEW_CONTEXT_FAILURE_CODES = [
+    "review-context-invalid-contract",
+    "review-context-verification-unbound",
+    "review-context-ledger-drift",
+    "review-context-manifest-missing",
+];
+export class FrontendReviewContextFailure extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "FrontendReviewContextFailure";
+        this.code = code;
+    }
+}
 async function readRequiredJson(runDir, relativePath) {
     try {
         return JSON.parse(await readFile(path.join(runDir, relativePath), "utf8"));
     }
-    catch {
-        throw new Error(`frontend review context missing or invalid ${relativePath}`);
+    catch (error) {
+        throw new FrontendReviewContextFailure("review-context-manifest-missing", `frontend review context missing or invalid ${relativePath}: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 async function readOptionalLintAssessment(runDir) {
@@ -32,8 +54,9 @@ async function readOptionalLintAssessment(runDir) {
 }
 function assertReviewEvidence(input) {
     const contract = frontendImplementationContractSchema.safeParse(input.contract);
-    if (!contract.success)
-        throw new Error("frontend review context invalid implementation contract");
+    if (!contract.success) {
+        throw new FrontendReviewContextFailure("review-context-invalid-contract", "frontend review context invalid implementation contract");
+    }
     const trace = input.verificationTrace;
     const expectedTargets = new Map(contract.data.verificationTargets.map((target) => [target.id, target]));
     const actualTargets = Array.isArray(trace?.targets) ? trace.targets : [];
@@ -69,17 +92,19 @@ function assertReviewEvidence(input) {
         actualIds.size !== expectedTargets.size ||
         !mockEvidenceBound ||
         trace.mockStrategy !== contract.data.mockApi.strategy) {
-        throw new Error("frontend review context verification trace is not bound to a passing contract");
+        throw new FrontendReviewContextFailure("review-context-verification-unbound", "frontend review context verification trace is not bound to a passing contract");
     }
     const assessment = frontendRepairAssessmentSchema.safeParse(input.repairAssessment);
-    if (!assessment.success)
-        throw new Error("frontend review context invalid repair assessment");
+    if (!assessment.success) {
+        throw new FrontendReviewContextFailure("review-context-invalid-contract", "frontend review context invalid repair assessment");
+    }
 }
 export async function runFrontendReviewContextGate(input) {
     const contract = await readRequiredJson(input.runDir, "contracts/frontend-implementation-contract.json");
     const parsedContract = frontendImplementationContractSchema.safeParse(contract);
-    if (!parsedContract.success)
-        throw new Error("frontend review context invalid implementation contract");
+    if (!parsedContract.success) {
+        throw new FrontendReviewContextFailure("review-context-invalid-contract", "frontend review context invalid implementation contract");
+    }
     const diff = await runFrontendWorktreeDiffGate({
         ...input,
         authorizedChangedPaths: parsedContract.data.targets.files,
@@ -88,6 +113,9 @@ export async function runFrontendReviewContextGate(input) {
     const repairAssessment = await readRequiredJson(input.runDir, "contracts/frontend-repair-assessment.json");
     const lintAssessment = await readOptionalLintAssessment(input.runDir);
     assertReviewEvidence({ contract, verificationTrace, repairAssessment });
+    // Source fidelity ledger 核对（AC-008 / AC-FIDELITY-008）：ledger 缺失/漂移即阻断；
+    // 同时把核对清单注入 review-context 供最终 reviewer 机械化核对。
+    const sourceFidelity = await buildReviewSourceFidelityChecklist(input, parsedContract.data);
     const payload = {
         schemaVersion: 1,
         schemaId: FRONTEND_REVIEW_CONTEXT_SCHEMA_ID,
@@ -95,6 +123,7 @@ export async function runFrontendReviewContextGate(input) {
         verificationTrace,
         repairAssessment,
         ...(lintAssessment ? { lintAssessment } : {}),
+        sourceFidelity,
         diff: {
             schemaId: diff.schemaId,
             patchPath: diff.patchPath,
@@ -107,6 +136,59 @@ export async function runFrontendReviewContextGate(input) {
     const artifactPath = await writeDagRunJsonArtifact(input.runDir, "contracts/frontend-review-context.json", payload);
     return { ok: true, artifactPath, diff };
 }
+/**
+ * 最终 review 核对清单（机械化）：ledger 缺失/漂移、canonical requirement 漏项、
+ * diff 越界、验证证据缺失均阻断 pass。清单以有界安全摘要注入提示词，不泄漏原文。
+ */
+async function buildReviewSourceFidelityChecklist(input, contract) {
+    const binding = contract.sourceBinding;
+    const checklist = [];
+    // 契约级 sourceBinding 的 v2 语义：四个 ledger 字段必须齐全（缺失即 v1 遗留绑定）。
+    const boundV2 = Boolean(binding.ledgerPath) &&
+        Boolean(binding.ledgerSha256) &&
+        Boolean(binding.inputDigest) &&
+        binding.requirementToFragments !== undefined;
+    if (!boundV2) {
+        return {
+            bound: false,
+            ledger: null,
+            checklist: [
+                "source fidelity ledger: not bound (v1 binding); 按现有语义评审",
+                "canonical contract 与实际 diff 逐项核对，验证证据齐全后 verdict 可为 pass",
+            ],
+        };
+    }
+    const absolute = resolveDagTaskSourcePath({
+        workspaceRoot: input.workspaceRoot,
+        taskId: contract.sourceBinding.taskId,
+        sourcePath: binding.ledgerPath,
+    });
+    let ledger = null;
+    try {
+        const raw = await readFile(absolute, "utf8");
+        const actualSha = createHash("sha256").update(raw).digest("hex");
+        if (actualSha !== binding.ledgerSha256) {
+            throw new Error(`ledger sha256 mismatch (bound ${binding.ledgerSha256}, observed ${actualSha})`);
+        }
+        ledger = parseLedgerJson(raw);
+    }
+    catch (error) {
+        // AC-011 / AC-HARD-005：v2 drift 返回结构化 failure code（稳定枚举 + reason），
+        // 不再裸 throw new Error；message 保持人类可读供 shell stderr。
+        throw new FrontendReviewContextFailure("review-context-ledger-drift", `frontend review context source fidelity ledger unavailable or drifted: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    checklist.push("ledger: 存在且绑定 sha256 一致（无缺失/漂移）", `ledger 覆盖统计: ${ledgerStatsLine(ledger)}`, "canonical contract requirements 必须覆盖 ledger 全部 canonical requirement IDs", "实际 diff 必须限制在契约 targets 内（越界即阻断 pass）", "验证证据必须绑定契约 verificationTargets（缺失即阻断 pass）", "仅满足派生摘要而遗漏 ledger requirement 时 verdict 不得为 pass");
+    return {
+        bound: true,
+        ledger: {
+            path: binding.ledgerPath,
+            sha256: binding.ledgerSha256,
+            inputDigest: binding.inputDigest,
+            stats: ledgerStatsLine(ledger),
+        },
+        checklist,
+    };
+}
 export function formatFrontendReviewContextStdout(result) {
     return [
         "Frontend review context: pass",

package/dist/workflows/dag/init-hybrid.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { access, readdir, readFile, realpath } from "node:fs/promises";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { assertValidDagSpec } from "./validate.js";
@@ -22,6 +22,9 @@ import { discoverProjectGovernancePresence } from "./project-governance-context.
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { materializeTaskReferenceDocs } from "../../task/source-references.js";
 import { observeTaskContract } from "../../task/contract/observe.js";
+import { extractRequirementFactsFromMarkdown } from "../../task/source-prepare/parse-intent.js";
+import { computeLedgerInputDigest, parseLedgerJson, recoverLedgerInputContract, } from "../../task/source-prepare/ledger.js";
+import { REQUIREMENT_LEDGER_FILE_NAME } from "../../task/contract/constants.js";
 import { dagHasWriterExecution } from "./task-contract-binding.js";
 import { DEFAULT_VERIFY_TIMEOUT_MS, resolveVerifyPreset, } from "../../executors/shell-verification.js";
 import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
@@ -1477,7 +1480,7 @@ export function extractTaskScopedRequirementIds(requirementMarkdown, ...fallback
         .sort((a, b) => a - b);
     return numbered.map((value) => `AC-${value}`);
 }
-function buildDagSourceBinding(sources) {
+function buildDagSourceBindingBase(sources) {
     const sourceEntries = [
         {
             kind: "requirement",
@@ -1512,6 +1515,124 @@ function buildDagSourceBinding(sources) {
         requirementIds: extractTaskScopedRequirementIds(sources.requirementMarkdown, sources.constraintMarkdown, ...(sources.referenceDocuments ?? []).map((reference) => reference.markdown)),
     };
 }
+/**
+ * Source binding v2（AC-001 / AC-FIDELITY-REPAIR-001）：仅 frontend taskKind 且存在
+ * 可解析 requirement/acceptance 引用时产出 schemaVersion=2 绑定（ledger 指针 +
+ * requirement→fragment 映射全部必填）。绑定完全来自 task advance 已持久化的
+ * source/requirement-ledger.json（intake 侧同一份受管账本的原始字节/hash/inputDigest），
+ * 绝不从 materialized reference path 重建语义等价但 path/hash 不同的 ledger；
+ * 缺失/损坏/漂移 fail closed（SOURCE_FIDELITY_LEDGER_MISSING / _STALE）。
+ */
+function buildDagSourceBinding(sources, taskKind) {
+    const base = buildDagSourceBindingBase(sources);
+    if (taskKind !== "frontend-implementation")
+        return base;
+    const ledgerBinding = loadPersistedFrontendSourceBindingLedger(sources);
+    if (!ledgerBinding)
+        return base;
+    // AC-002 / AC-HARD-002：物化 REQ-SRC-* canonical id 确定性并入 v2 requirementIds。
+    // 生成型 REQ-SRC-* id 无法从 markdown 文本导出（必须来自持久化 ledger），此处
+    // 在 required requirement ids 侧确定性注入，确保 prewrite missing-requirement-ids
+    // 不误伤（不要求文本可导出）也不漏检（物化 id 必须被契约覆盖）。
+    const materializedRequirementIds = Object.keys(ledgerBinding.requirementToFragments)
+        .filter((id) => /^REQ-SRC-/.test(id) && !base.requirementIds.includes(id))
+        .sort();
+    return {
+        schemaVersion: 2,
+        taskId: base.taskId,
+        sources: base.sources,
+        requirementIds: [
+            ...base.requirementIds,
+            ...materializedRequirementIds,
+        ],
+        ledgerPath: ledgerBinding.ledgerPath,
+        ledgerSha256: ledgerBinding.ledgerSha256,
+        inputDigest: ledgerBinding.inputDigest,
+        requirementToFragments: ledgerBinding.requirementToFragments,
+    };
+}
+/**
+ * 读取 Task Contract 已持久化的 source/requirement-ledger.json，核验字节 sha256
+ * 与 inputDigest（与当前源输入 digest 一致）后产出 v2 绑定字段。缺失/损坏/漂移
+ * 抛稳定错误（SOURCE_FIDELITY_LEDGER_MISSING / SOURCE_FIDELITY_LEDGER_STALE）。
+ * 新鲜度侧不再"重新推导"权威输入，而是从持久化 ledger 恢复 build 侧的输入合同
+ * （与 ledger build 使用完全相同的输入），避免 contract apply 重投影派生导航视图
+ * 需求.md 导致重抽取漂移误判 stale（AC-DIGEST-001/002/003）。
+ */
+function loadPersistedFrontendSourceBindingLedger(sources) {
+    const referenceDocs = (sources.referenceDocuments ?? []).filter((doc) => doc.markdown.trim().length > 0);
+    if (referenceDocs.length === 0)
+        return null;
+    // 存在性守卫（保持既有 v1 回退行为）：派生视图无可抽取 requirement/acceptance
+    // 引用时不要求持久化 ledger，直接回退 base binding。此守卫只用于"是否 ledger
+    // 任务"判定，绝不参与 digest 键计算——键输入完全来自持久化 ledger 恢复。
+    const guardFacts = extractRequirementFactsFromMarkdown(sources.requirementMarkdown);
+    if (guardFacts.acceptanceCriteria.length === 0)
+        return null;
+    const ledgerAbsolutePath = path.join(sources.taskDir, "source", REQUIREMENT_LEDGER_FILE_NAME);
+    let raw;
+    try {
+        raw = readFileSync(ledgerAbsolutePath, "utf8");
+    }
+    catch (error) {
+        throw new Error(`SOURCE_FIDELITY_LEDGER_MISSING: frontend task ${sources.taskId} has resolvable requirement/acceptance references but no persisted ${REQUIREMENT_LEDGER_FILE_NAME} at ${ledgerAbsolutePath}; run task advance (intake) to persist the ledger before dag init-hybrid (${error instanceof Error ? error.message : String(error)})`);
+    }
+    const ledgerSha256 = createHash("sha256").update(raw).digest("hex");
+    let ledger;
+    try {
+        ledger = parseLedgerJson(raw);
+    }
+    catch (error) {
+        throw new Error(`SOURCE_FIDELITY_LEDGER_MISSING: persisted ${REQUIREMENT_LEDGER_FILE_NAME} is not a valid v1 ledger: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // canonical 侧：ledger.canonicalRequirements 按 build 顺序原样保留输入 canonical
+    // requirements（id/text 逐字节），过滤物化 REQ-SRC-*（AC-HARD-002 "物化不入键"）
+    // 即精确恢复 digest 输入集；派生导航视图 需求.md 投影不参与键计算。
+    const contract = recoverLedgerInputContract(ledger);
+    if (contract.canonicalRequirements.length === 0) {
+        // AC-HARD-003：存在 v2 ledger 但 canonical requirements 为空时 fail closed，
+        // 绝不回退 v1 base 绑定（buildDagSourceBinding 不降级）。空 canonical 的 ledger
+        // 无法提供 requirement→fragment 映射证据，任何 v1 回退都会静默放行 fail-open。
+        throw new Error(`SOURCE_FIDELITY_LEDGER_STALE: persisted ${REQUIREMENT_LEDGER_FILE_NAME} has an empty canonical requirement set; refusing to fall back to a v1 base binding; re-run task advance (intake) to rebuild the ledger`);
+    }
+    // source 侧：ledger.sourcePaths（build 时权威 sourceDocuments 的 repo-root
+    // relative POSIX 路径集合）作为权威身份集合，对当前 materialized reference 文件
+    // 做交集过滤；内容取当前字节（漂移检测）。权威路径缺失（删除/清空/重命名）→
+    // fail-closed STALE；新增的非权威 role 文件被正确排除（不入键）。
+    const currentByPath = new Map();
+    for (const doc of referenceDocs) {
+        currentByPath.set(toDagSourcePath(sources, doc.path), doc.markdown);
+    }
+    const missingAuthoritativePaths = contract.sourcePaths.filter((sourcePath) => !currentByPath.has(sourcePath));
+    if (missingAuthoritativePaths.length > 0) {
+        throw new Error(`SOURCE_FIDELITY_LEDGER_STALE: persisted ${REQUIREMENT_LEDGER_FILE_NAME} was built from authoritative source documents no longer present (${missingAuthoritativePaths.join(", ")}); re-run task advance (intake) to rebuild the ledger`);
+    }
+    // inputDigest 新鲜度：与当前源输入（canonical repo-root relative identity）一致。
+    // digest 只绑定语义权威输入（规范化源文档 + canonical requirements +
+    // schema/reconciler version）；派生导航视图 需求.md 投影不参与键计算。
+    const expectedDigest = computeLedgerInputDigest({
+        sourceDocuments: contract.sourcePaths.map((sourcePath) => ({
+            path: sourcePath,
+            content: currentByPath.get(sourcePath),
+        })),
+        canonicalRequirements: contract.canonicalRequirements,
+    });
+    if (ledger.inputDigest !== expectedDigest) {
+        throw new Error(`SOURCE_FIDELITY_LEDGER_STALE: persisted ${REQUIREMENT_LEDGER_FILE_NAME} inputDigest ${ledger.inputDigest} does not match current source input ${expectedDigest}; re-run task advance (intake) to rebuild the ledger`);
+    }
+    const requirementToFragments = {};
+    for (const requirement of ledger.canonicalRequirements) {
+        if (requirement.sourceFragmentIds.length > 0) {
+            requirementToFragments[requirement.id] = requirement.sourceFragmentIds;
+        }
+    }
+    return {
+        ledgerPath: toDagSourcePath(sources, ledgerAbsolutePath),
+        ledgerSha256,
+        inputDigest: ledger.inputDigest,
+        requirementToFragments,
+    };
+}
 function buildBackendTestAnalysisSourceBindingContract(sources) {
     const binding = buildDagSourceBinding(sources);
     const requirement = binding.sources.find((source) => source.kind === "requirement");
@@ -2416,7 +2537,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             allowedPaths: taskConfig.allowedPaths,
             complexity: taskConfig.complexity,
         });
-    const frontendSourceBinding = buildDagSourceBinding(sources);
+    const frontendSourceBinding = buildDagSourceBinding(sources, taskConfig.taskKind);
     const frontendContractSkeleton = buildFrontendImplementationContractSkeleton({
         sourceBinding: frontendSourceBinding,
         riskLevel: frontendRisk.selectedRisk,
@@ -6563,7 +6684,7 @@ async function buildHybridDagForTemplate(sources, template, options = {}) {
     if (!spec.runtimeContract) {
         spec.runtimeContract = GENERATED_DAG_RUNTIME_CONTRACT;
     }
-    spec.sourceBinding = buildDagSourceBinding(sources);
+    spec.sourceBinding = buildDagSourceBinding(sources, template === "frontend-implementation" ? "frontend-implementation" : undefined);
     spec.taskContractBinding = taskContractBinding;
     assertNoGovernanceFlagOnDisallowedTemplate(spec, template);
     if (template === "standard-dag" ||

package/dist/workflows/dag/node-execution.js

@@ -3,6 +3,7 @@ import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { recordDecisionEnvelopeForNode, shouldPauseOnHumanEscalation, writeHumanEscalationArtifacts, } from "./decision-envelope.js";
 import { FRONTEND_PREWRITE_RESULT_SOURCE_ARTIFACT, FRONTEND_WRITER_NODE_IDS, isFrontendWriterAuthorized, readFrontendPrewriteResult, } from "./scheduler.js";
 import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
@@ -306,6 +307,35 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
         "</retry_instruction>",
     ].join("\n");
 }
+const PROMPT_RESTART_CANDIDATE_MAX_BYTES = 64 * 1024;
+function promptRestartCandidateForAttempt(input) {
+    if (input.attemptPrompt === input.baseRuntimePrompt) {
+        return input.taskPrompt;
+    }
+    const appendedPrefix = `${input.baseRuntimePrompt}\n\n`;
+    if (input.attemptPrompt.startsWith(appendedPrefix)) {
+        return [
+            input.taskPrompt,
+            input.attemptPrompt.slice(appendedPrefix.length),
+        ]
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    return input.attemptPrompt;
+}
+async function persistFailedPromptRestartCandidate(input) {
+    const redacted = redactSecrets(input.prompt);
+    const preview = truncateUtf8Preview(redacted, PROMPT_RESTART_CANDIDATE_MAX_BYTES);
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, `prompt-candidate-attempt-${input.attempt}.json`, {
+        schemaVersion: 1,
+        attempt: input.attempt,
+        failureCategory: input.failureCategory ?? "unknown",
+        prompt: preview,
+        truncated: preview !== redacted,
+        maxBytes: PROMPT_RESTART_CANDIDATE_MAX_BYTES,
+        sha256: createHash("sha256").update(redacted).digest("hex"),
+    });
+}
 export async function buildNodePromptWithResolvedSkillInstructions(spec, task, upstream, cwd, options) {
     const policy = resolveContextPolicy(spec);
     const skillNames = policy.resolveSkills(spec, task);
@@ -770,6 +800,7 @@ export async function executeDagNode(input) {
         // exactly this attempt's segment (B1: earlier attempts legitimately use
         // ls/find and must not be attributed to the repair attempt).
         const attemptSessionEventsOffset = await sessionEventsByteLength(runDir, nodeId);
+        let promptRestartCandidate = task.subtask_prompt;
         let result;
         try {
             validateRepairArtifactGateBeforeShell({
@@ -833,6 +864,11 @@ export async function executeDagNode(input) {
                     previousReason: previousProtocolReason,
                 });
             }
+            promptRestartCandidate = promptRestartCandidateForAttempt({
+                taskPrompt: task.subtask_prompt,
+                baseRuntimePrompt: prompt,
+                attemptPrompt,
+            });
             result = await executeNode({
                 task,
                 cwd,
@@ -960,6 +996,15 @@ export async function executeDagNode(input) {
         const attemptWallDurationMs = durationBetween(attemptStartedAt, attemptFinishedAt);
         totalAttemptWallDurationMs += attemptWallDurationMs;
         const rawFailureCategory = result.rawFailureCategory ?? result.failureCategory;
+        if (task.executor === "pi" && !result.ok) {
+            await persistFailedPromptRestartCandidate({
+                runDir,
+                nodeId,
+                attempt: attemptNumber,
+                failureCategory: result.failureCategory,
+                prompt: promptRestartCandidate,
+            });
+        }
         const attemptRecord = {
             attempt: attemptNumber,
             startedAt: attemptStartedAt,