@tea-agent/loop-agent 0.39.0-beta.7 → 0.39.0-beta.9

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";
@@ -9,6 +9,7 @@ import { bindDagRerunFeedback } from "./rerun-feedback.js";
 import { planMavenVerification, } from "../../verification/maven/index.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { DEFAULT_OPENSPEC_GOVERNANCE_ROOT, DEFAULT_FRONTEND_SPEC_ROOTS, extractTaskSourceFrontendSpecPaths, } from "../../shared/openspec-spec.js";
+import { readFrontendSpecRegistry, scoreFrontendSpecCandidate, } from "../../task/frontend-project-capability.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
 import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PLANNER_OUTPUT_LIMIT_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, WRITER_TRANSPORT_RETRY_POLICY, FRONTEND_PLAN_LADDER_RETRY_POLICY, FRONTEND_REVIEW_TERMINAL_RETRY_POLICY, TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE, TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY, isCanonicalFinalVerifyShellRetryCandidate, isSafeReadOnlyPiRetryCandidate, isTargetTemplateImplementPi, isWriterTransportRetryCandidate, } from "./retry-policy.js";
@@ -22,6 +23,9 @@ import { discoverProjectGovernancePresence } from "./project-governance-context.
 import { CANONICAL_TASK_ID_PATTERN, 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";
@@ -103,6 +107,13 @@ const FRONTEND_BOUNDED_IMPLEMENT_SKILLS = ["frontend-bounded-implement"];
 const FRONTEND_DESIGN_REVIEW_SKILLS = ["frontend-design-review"];
 const FRONTEND_REVIEW_SKILLS = ["frontend-review"];
 const FRONTEND_VERIFICATION_SKILLS = ["frontend-verification"];
+const FRONTEND_READ_BUDGETS = {
+    contract: { maxFiles: 24, maxBytes: 384 * 1024 },
+    scout: { maxFiles: 48, maxBytes: 768 * 1024 },
+    plan: { maxFiles: 32, maxBytes: 512 * 1024 },
+    designReview: { maxFiles: 16, maxBytes: 256 * 1024 },
+    finalReview: { maxFiles: 20, maxBytes: 320 * 1024 },
+};
 const IMPLEMENT_WRITESET_PLACEHOLDER = "REPLACE/WITH/NARROW/IMPLEMENT/PATHS/**";
 /**
  * Runtime contract stamped on every newly generated DAG. Capability fields are
@@ -1501,7 +1512,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",
@@ -1536,6 +1547,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");
@@ -1552,7 +1681,10 @@ function buildBackendTestAnalysisSourceBindingContract(sources) {
         requirementIds: binding.requirementIds,
     };
 }
-function buildSourceContextBlock(sources) {
+function buildSourceContextBlock(sources, options = {}) {
+    const includeRequirementExcerpt = options.includeRequirementExcerpt ?? true;
+    const includeConstraintExcerpt = options.includeConstraintExcerpt ?? true;
+    const includeReferenceDocuments = options.includeReferenceDocuments ?? true;
     const requirementRef = toDagSourcePath(sources, sources.requirementPath);
     const requirementExcerpt = excerptMarkdown(sources.requirementMarkdown, {
         sourceRef: requirementRef,
@@ -1561,7 +1693,7 @@ function buildSourceContextBlock(sources) {
     const parts = [
         `## Task source: 需求.md`,
         `Bound readPath (use for Pi read-tool calls): ${requirementRef}`,
-        requirementExcerpt.text,
+        ...(includeRequirementExcerpt ? [requirementExcerpt.text] : []),
     ];
     if (sources.constraintMarkdown) {
         const constraintRef = toDagSourcePath(sources, sources.constraintPath);
@@ -1569,9 +1701,11 @@ function buildSourceContextBlock(sources) {
             sourceRef: constraintRef,
         });
         boundReadPaths.push(`- constraints: ${constraintRef}`);
-        parts.push("## Task source: 执行约束.md", `Bound readPath (use for Pi read-tool calls): ${constraintRef}`, constraintExcerpt.text);
+        parts.push("## Task source: 执行约束.md", `Bound readPath (use for Pi read-tool calls): ${constraintRef}`, ...(includeConstraintExcerpt ? [constraintExcerpt.text] : []));
     }
-    for (const reference of (sources.referenceDocuments ?? []).slice(0, MAX_INLINE_SOURCE_REFERENCE_DOCUMENTS)) {
+    for (const reference of (includeReferenceDocuments
+        ? sources.referenceDocuments ?? []
+        : []).slice(0, MAX_INLINE_SOURCE_REFERENCE_DOCUMENTS)) {
         const relativePath = path
             .relative(path.join(sources.taskDir, "source"), reference.path)
             .replaceAll(path.sep, "/");
@@ -1859,6 +1993,7 @@ export function buildStandardHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: "MED",
                 writePolicy: "read-only",
+                readBudget: FRONTEND_READ_BUDGETS.contract,
                 allowedPaths: taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"],
                 forbiddenPaths,
                 outputContract: "Plain Markdown implementation contract (10 lines or fewer); no file writes.",
@@ -1875,6 +2010,7 @@ export function buildStandardHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: scoutComplexity,
                 writePolicy: "read-only",
+                readBudget: FRONTEND_READ_BUDGETS.scout,
                 allowedPaths: scoutPaths.srcPaths,
                 forbiddenPaths,
                 outputContract: "Plain Markdown source reconnaissance summary; no file writes.",
@@ -1891,6 +2027,7 @@ export function buildStandardHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: scoutComplexity,
                 writePolicy: "read-only",
+                readBudget: FRONTEND_READ_BUDGETS.plan,
                 allowedPaths: scoutPaths.testPaths,
                 forbiddenPaths,
                 outputContract: "Plain Markdown test coverage reconnaissance summary; no file writes.",
@@ -2282,7 +2419,24 @@ export function filterRelevantOpenspecCandidates(input) {
         }
     }
     // 保持候选发现顺序（确定性）；mandatory 与相关候选都按原始顺序出现。
-    return relevant;
+    const maxCandidates = input.maxCandidates ?? 24;
+    if (relevant.length <= maxCandidates)
+        return relevant;
+    const mandatoryRelevant = relevant.filter((candidate) => mandatory.has(candidate));
+    const optionalRelevant = relevant.filter((candidate) => !mandatory.has(candidate));
+    return [
+        ...mandatoryRelevant,
+        ...optionalRelevant.slice(0, Math.max(0, maxCandidates - mandatoryRelevant.length)),
+    ];
+}
+function buildFrontendSpecCandidateSummaries(input) {
+    const mandatory = new Set(input.mandatoryPaths);
+    return input.paths
+        .map((candidate) => scoreFrontendSpecCandidate(candidate, "", {
+        registryMode: input.registryModes.get(candidate),
+        taskRelated: mandatory.has(candidate) || openspecCandidateMatchesSource(candidate, input.sourceMarkdown),
+    }))
+        .sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
 }
 /**
  * 候选路径是否与任务源相关：从任务源提取文件名/路径 token（去扩展名、
@@ -2347,6 +2501,21 @@ async function resolveFrontendOpenspecGateConfig(sources) {
     const remappedSourceMarkdown = rootAliases.reduce((markdown, { alias, logicalRoot }) => markdown.replace(new RegExp(`(^|[^A-Za-z0-9_.-])${alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/`, "g"), `$1${logicalRoot}/`), [sources.requirementMarkdown, sources.constraintMarkdown ?? ""].join("\n"));
     const taskSourceCited = extractTaskSourceFrontendSpecPaths(remappedSourceMarkdown, specRoots, governanceRoot);
     const scanStrict = sources.frontendProjectCapability?.designEvidence.normativePaths ?? [];
+    const registry = sources.repoRoot
+        ? await readFrontendSpecRegistry(sources.repoRoot)
+        : null;
+    const registryModes = new Map();
+    for (const root of registry?.roots ?? []) {
+        if (root.scope && !root.scope.includes("frontend"))
+            continue;
+        if (!root.mode)
+            continue;
+        for (const candidate of scanStrict) {
+            if (candidate === root.path || candidate.startsWith(`${root.path}/`)) {
+                registryModes.set(candidate, root.mode);
+            }
+        }
+    }
     const dedupeSorted = (paths) => [...new Set(paths)].sort();
     const openspecCandidateSources = {
         declared: dedupeSorted(declared),
@@ -2356,16 +2525,30 @@ async function resolveFrontendOpenspecGateConfig(sources) {
     // Candidate discovery is frozen independently from the eventual must-read
     // set. The selector may mark candidates irrelevant, while explicit task
     // declarations/source citations are never allowed to be downgraded.
-    const openspecMandatoryPaths = dedupeSorted([...declared, ...taskSourceCited]);
-    const openspecCandidatePaths = dedupeSorted([
-        ...openspecCandidateSources.scanStrict,
-        ...openspecMandatoryPaths,
+    const openspecMandatoryPaths = dedupeSorted([
+        ...declared,
+        ...taskSourceCited,
     ]);
+    // `cited` must stay demand-driven: a normative registry makes a path
+    // discoverable, not implicitly task-mandatory. Only scan-strict may offer
+    // the global discovery set to the bounded task-relevance selector.
+    const openspecCandidatePaths = policy === "cited"
+        ? openspecMandatoryPaths
+        : dedupeSorted([
+            ...openspecCandidateSources.scanStrict,
+            ...openspecMandatoryPaths,
+        ]);
     const result = {
         openspecPolicy: policy,
         openspecCandidatePaths,
         openspecCandidateSources,
         openspecMandatoryPaths,
+        openspecCandidateSummaries: buildFrontendSpecCandidateSummaries({
+            paths: openspecCandidatePaths,
+            mandatoryPaths: openspecMandatoryPaths,
+            registryModes,
+            sourceMarkdown: [sources.requirementMarkdown, sources.constraintMarkdown ?? ""].join("\n"),
+        }),
     };
     if (sources.repoRoot && openspecCandidatePaths.length > 0) {
         result.openspecCandidateSnapshots = await Promise.all(openspecCandidatePaths.map(async (candidate) => ({
@@ -2381,10 +2564,10 @@ const frontendComponentConformanceInstruction = [
     "## Component Selection conformance (uiComponentChoices; hard rule)",
     "每个 UI 用途必须在契约的 uiComponentChoices[] 中声明组件选型：{ purpose, component, decision, specReference, rationale }。",
     "- decision=specified：前端规范（候选组件/主题桶 + 任务源显式引用）已定义该用途组件 → 必须使用该组件，并给精确 specReference { path, section, line }（path 必须是 openspec/ai_workspace 受支持规范路径）。",
-    "- decision=reuse-existing：复用仓库既有组件/惯例（规范未点名）→ specReference 可为 null，rationale 说明复用的现有组件与依据。",
-    "- decision=new：规范与既有代码均无合适组件 → specReference 必须为 null，rationale 必须说明偏差理由（design-review 审，最终 review 复核）。",
+    "- decision=reuse-existing：仅当该组件/惯例**确实已存在于仓库当前代码**（如复用现有 ActiveRunBadge 的 oc- class 惯例）→ specReference 可为 null，rationale 必须指明复用的具体现有组件/文件与依据。",
+    "- decision=new：任务源/PRD 要求**新增**该组件（仓库当前不存在该组件文件）→ decision 必须为 new，不得标 reuse-existing；specReference 指向任务源 PRD 中定义该组件的 { path, section, line }（path 为 bound PRD 路径，如 .harness/tasks/<taskId>/source/references/prd.md），rationale 说明新增纯展示组件、复用既有 CSS 命名与主题变量约定；design-review 会复核 specReference 可追溯性。",
     "不得静默替换规范组件或自创组件而无偏差声明；spec 已定义该用途组件时不得改选其它组件。",
-    "prewrite gate 确定性交叉校验：specReference.path 非法 → component-spec-reference-invalid；specReference.path 未在 typed decision ledger 中声明或缺少成功 read 事件 → component-spec-not-cited；候选桶非空且契约有 UI 可见工作而 uiComponentChoices 缺失/空 → component-choices-missing。",
+    "prewrite gate 确定性交叉校验：仅 decision=specified 的 specReference 必须是候选 OpenSpec 路径、在 typed decision ledger 中声明且有成功 read 事件；decision=new 的 PRD 引用走任务源可追溯性审查，不得按 OpenSpec 候选拒绝。候选桶非空且契约有 UI 可见工作而 uiComponentChoices 缺失/空 → component-choices-missing。",
 ].join("\n");
 function resolveFrontendCapabilityContextBlock(sources) {
     const risk = sources.frontendRisk;
@@ -2398,34 +2581,7 @@ function resolveFrontendCapabilityContextBlock(sources) {
     }
     if (capability) {
         parts.push("", capability.adapterGuidance);
-        const classified = capability.designEvidence.classified;
-        const bucketLines = [];
-        const pushBucket = (label, paths) => {
-            if (paths.length > 0)
-                bucketLines.push(`${label}: ${paths.join(", ")}`);
-        };
-        pushBucket("schemas", classified.schemas);
-        pushBucket("code-template", classified.codeTemplate);
-        pushBucket("rule.api", classified.rule.api);
-        pushBucket("rule.mock", classified.rule.mock);
-        pushBucket("rule.router", classified.rule.router);
-        pushBucket("rule.hooks", classified.rule.hooks);
-        pushBucket("rule.utils", classified.rule.utils);
-        pushBucket("rule.components", classified.rule.components);
-        pushBucket("rule.other", classified.rule.other);
-        pushBucket("theme", classified.theme);
-        pushBucket("component", classified.component);
-        pushBucket("ui-other", classified.uiOther);
-        pushBucket("advisory-other", classified.advisoryOther);
-        parts.push("## Classified openspec specification paths (role semantics)");
-        if (bucketLines.length > 0) {
-            parts.push(...bucketLines);
-        }
-        else {
-            parts.push("(no openspec specification paths discovered — greenfield)");
-        }
-        parts.push("component / theme / rule.components 是「组件/主题规范」必读语义桶：规范已定义某用途组件时必须使用它（uiComponentChoices 用 decision=specified + 精确 path/section/line），不得静默替换为自认更合适的组件；无规范定义时才允许 reuse-existing 或 new（new 必须声明偏差 rationale）。这些路径在生成期冻结为 prewrite gate 的 componentSpecCandidatePaths。");
-        parts.push("Each consuming node MUST report in its output: applicable rules, the hit path/section/line number for every applied specification, and any conflicts or missing specifications. Missing or conflicting required specifications must fail closed rather than silently substituting nearby repository conventions.");
+        parts.push("Task-relevant OpenSpec candidates are injected separately as a bounded Top-K index. The deterministic prewrite gate retains the complete frozen candidate set; unlisted candidates are neither silently required nor evidence of a missing specification.");
         parts.push(`A11y capability: ${capability.a11y.status}` +
             (capability.a11y.tools.length
                 ? ` (${capability.a11y.tools.join(", ")})`
@@ -2658,7 +2814,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         }),
         shapeTransitionCapsule: resolveFrontendShapeCapsuleGenerationInput(sources),
     });
-    const frontendSourceBinding = buildDagSourceBinding(sources);
+    const frontendSourceBinding = buildDagSourceBinding(sources, taskConfig.taskKind);
     const frontendContractSkeleton = buildFrontendImplementationContractSkeleton({
         sourceBinding: frontendSourceBinding,
         riskLevel: frontendRisk.selectedRisk,
@@ -2682,7 +2838,9 @@ async function buildFrontendHybridDagFromTask(sources) {
             "",
             "## Critical rules",
             "- verificationTargets is a TOP-LEVEL required array",
+            "- Every verificationTargets[] entry MUST carry uiStates. Use uiStates: [] when it does not verify a named UI state; never omit the key in a canonical contract.",
             "- uiStates items use name/applicable/expectedBehavior/implementationTargets/verificationTargetIds/notApplicableReason",
+            "- interactions items use name/trigger/expectedBehavior/implementationTargets/verificationTargetIds",
             "- Use uiStates: [] for frontend logic changes with no user-visible UI state. Do not invent UI states.",
             "- For applicable=true, provide non-empty expectedBehavior plus non-empty implementationTargets and verificationTargetIds. For applicable=false, provide non-empty notApplicableReason and omit expectedBehavior instead of emitting an empty string.",
             "- mockApi.productionDefaultOff must always be true (including strategy: not-needed)",
@@ -2692,6 +2850,13 @@ async function buildFrontendHybridDagFromTask(sources) {
             "",
             "## Bad / Good contract field examples",
             "",
+            "### Common model key aliases — BAD / GOOD:",
+            '{"name":"error","applicable":false,"reason":"No failing request exists"}  <-- BAD: use notApplicableReason, never reason',
+            '{"name":"error","applicable":false,"notApplicableReason":"No failing request exists"}  <-- GOOD',
+            '{"id":"save-click","trigger":"User presses Save","expectedBehavior":"Persists the draft","implementationTargets":["src/save.ts"],"verificationTargetIds":["vt-1"]}  <-- BAD: use name, never id',
+            '{"name":"save-click","trigger":"User presses Save","expectedBehavior":"Persists the draft","implementationTargets":["src/save.ts"],"verificationTargetIds":["vt-1"]}  <-- GOOD',
+            '{"id":"vt-1","type":"unit","commandLabel":"npm run test:unit","file":"src/save.test.ts","requirementIds":["AC-001"]}  <-- BAD: uiStates is required; use uiStates: [] when unbound',
+            "",
             "### verificationTargets - BAD (invented commandLabel, missing file):",
             '{"id":"vt-1","type":"static","commandLabel":"lint","file":"","requirementIds":["AC-001"],"uiStates":[]}  <-- REJECTED: commandLabel not in frozen command set; empty file path',
             "",
@@ -2737,17 +2902,20 @@ async function buildFrontendHybridDagFromTask(sources) {
             "### uiComponentChoices - GOOD (specified with precise spec hit):",
             '{"purpose":"primary action button","component":"Button","decision":"specified","specReference":{"path":"openspec/schemas/button.md","section":"Variants","line":12},"rationale":"spec mandates Button for primary actions"}',
             "",
-            "### uiComponentChoices - GOOD (new with deviation rationale; specReference null):",
-            '{"purpose":"loading skeleton","component":"SkeletonCard","decision":"new","specReference":null,"rationale":"no spec or existing component covers skeleton; deviation pending design-review approval"}',
+            "### uiComponentChoices - GOOD (new component mandated by PRD; specReference points at the PRD section):",
+            '{"purpose":"task source badge","component":"TaskSourceBadge","decision":"new","specReference":{"path":".harness/tasks/<taskId>/source/references/prd.md","section":"需求","line":4},"rationale":"PRD mandates a new TaskSourceBadge component (not present in the repo); build it as a pure presentational component reusing existing oc- scoped classes and theme variables"}',
+            "",
+            "### uiComponentChoices - GOOD (reuse-existing only for a component actually present in the repo):",
+            '{"purpose":"status dot","component":"ActiveRunBadge","decision":"reuse-existing","specReference":null,"rationale":"ActiveRunBadge already exists in static-src and provides the oc- dot styling convention"}',
             "",
-            "### uiComponentChoices - BAD (specified without specReference, or new with specReference):",
-            '{"purpose":"primary action","component":"MyButton","decision":"specified","specReference":null,"rationale":"..."}  <-- REJECTED: specified requires specReference',
-            '{"purpose":"primary action","component":"MyButton","decision":"new","specReference":{"path":"openspec/schemas/button.md","section":"","line":null},"rationale":"..."}  <-- REJECTED: new must not carry specReference',
+            "### uiComponentChoices - BAD (mandated-new component marked reuse-existing, or new without PRD specReference):",
+            '{"purpose":"primary action","component":"TaskSourceBadge","decision":"reuse-existing","specReference":null,"rationale":"reuse existing component"}  <-- REJECTED: PRD mandates adding this component; it does not exist yet, so decision must be new with a PRD specReference',
+            '{"purpose":"loading skeleton","component":"SkeletonCard","decision":"new","specReference":null,"rationale":"no spec or existing component covers skeleton"}  <-- REJECTED: new must carry a task-source PRD specReference for traceability',
         ].join("\n");
     })();
     const frontendContractFieldSummary = [
         "## Contract field summary (authoritative JSON; no plan prose)",
-        "The plan node emits only a fenced json contract patch; frontend-design-policy-shell applies the runtime skeleton, validates, and materializes the canonical full contract JSON. There is no Markdown plan explanation to read. Review these fields:",
+        "frontend-plan-pi records typed facts; frontend-design-policy-shell applies the runtime skeleton, validates, and materializes the canonical full contract JSON supplied here. There is no separate plan prose authority. Review these fields:",
         "- requirements[]: id, expectedOutcome, implementationTargets, verificationTargetIds, evidenceGap",
         "- uiStates[]: name, applicable, expectedBehavior, implementationTargets, verificationTargetIds, notApplicableReason",
         "- interactions[]: name, trigger, expectedBehavior, implementationTargets, verificationTargetIds",
@@ -2757,14 +2925,36 @@ async function buildFrontendHybridDagFromTask(sources) {
         "- designEvidence: source, paths, conflicts; evidenceGaps[] (optional)",
         "- optional: stylingStrategy, uiComponentChoices[], dependencyPolicy, residualRisks[], realIntegrationGap",
         "- uiComponentChoices[]: purpose, component, decision (specified|reuse-existing|new), specReference { path, section, line } | null, rationale",
+        "- Common model aliases are never canonical: uiStates[].reason → uiStates[].notApplicableReason; interactions[].id → interactions[].name; verificationTargets[].uiStates must be an array (use [] when unbound).",
         "Do not require or read a separate plan prose section; the contract JSON is the only plan surface.",
     ].join("\n");
-    const sourceContext = [
-        buildSourceContextBlock(sources),
-        capabilityContextBlock,
-    ]
-        .filter(Boolean)
-        .join("\n\n");
+    // Do not carry every attachment through the whole frontend pipeline. The
+    // contract node is the sole requirements/materials synthesis point; scout
+    // and plan only need the canonical request plus constraints, while design
+    // review consumes the materialized contract and only needs source provenance.
+    // This prevents attachment content from accumulating on later review calls.
+    const sourceContexts = {
+        contract: [buildSourceContextBlock(sources), capabilityContextBlock]
+            .filter(Boolean)
+            .join("\n\n"),
+        scout: [
+            buildSourceContextBlock(sources, { includeReferenceDocuments: false }),
+            capabilityContextBlock,
+        ]
+            .filter(Boolean)
+            .join("\n\n"),
+        plan: [
+            buildSourceContextBlock(sources, { includeReferenceDocuments: false }),
+            capabilityContextBlock,
+        ]
+            .filter(Boolean)
+            .join("\n\n"),
+        designReview: buildSourceContextBlock(sources, {
+            includeRequirementExcerpt: false,
+            includeConstraintExcerpt: false,
+            includeReferenceDocuments: false,
+        }),
+    };
     const hasMockVerifyCommands = (taskConfig.frontendMock?.verifyCommands.length ?? 0) > 0 ||
         mockCapability.verifyCommands.length > 0;
     const requirementIds = frontendSourceBinding.requirementIds;
@@ -2951,13 +3141,34 @@ async function buildFrontendHybridDagFromTask(sources) {
     // 引用）始终保留；scan-strict 候选按路径段是否命中任务源关键词过滤。
     // runtime 的选型/read 门禁仍消费完整 openspecCandidatePaths——这里只
     // 减小 prompt 体积，不改变门禁语义；未提及的候选 runtime 默认 irrelevant。
-    const promptCandidates = filterRelevantOpenspecCandidates({
-        candidates: openspecGate.openspecCandidatePaths,
+    const promptCandidatePaths = filterRelevantOpenspecCandidates({
+        candidates: openspecGate.openspecCandidateSummaries.map((candidate) => candidate.path),
         mandatoryPaths: openspecGate.openspecMandatoryPaths,
         sourceMarkdown: [
             sources.requirementMarkdown,
             sources.constraintMarkdown ?? "",
         ].join("\n"),
+        maxCandidates: 24,
+    });
+    const candidateByPath = new Map(openspecGate.openspecCandidateSummaries.map((candidate) => [
+        candidate.path,
+        candidate,
+    ]));
+    // Preserve the filter's mandatory/relevance order. Sorting then slicing here
+    // used to be able to drop a mandatory path after it passed the Top-K filter.
+    const promptCandidates = promptCandidatePaths.flatMap((candidatePath) => {
+        const candidate = candidateByPath.get(candidatePath);
+        return candidate
+            ? [
+                {
+                    path: candidate.path,
+                    kind: candidate.kind,
+                    score: candidate.score,
+                    reasons: candidate.reasons,
+                    source: candidate.source,
+                },
+            ]
+            : [];
     });
     const openspecSelectionContext = JSON.stringify({
         schemaVersion: 1,
@@ -2965,6 +3176,14 @@ async function buildFrontendHybridDagFromTask(sources) {
         candidates: promptCandidates,
         mandatoryPaths: openspecGate.openspecMandatoryPaths,
     });
+    const scopedOpenspecContext = promptCandidates.length > 0
+        ? [
+            "## Task-relevant OpenSpec Top-K (generation frozen)",
+            `Policy: ${openspecGate.openspecPolicy}. This is the bounded prompt index; the deterministic gate retains ${openspecGate.openspecCandidatePaths.length} frozen candidates.`,
+            ...promptCandidates.map((candidate) => `- ${openspecGate.openspecMandatoryPaths.includes(candidate.path) ? "mandatory" : "candidate"}: ${candidate.path} (${candidate.kind}; ${candidate.source})`),
+            "Apply or cite only paths relevant to the concrete contract. Report applied rules with path/section/line and surface conflicts or missing specifications; unlisted candidates default to irrelevant unless the deterministic gate requires them.",
+        ].join("\n")
+        : "";
     // Generation-frozen component/theme specification bucket (ADR 0016). Derived
     // from the classified component/theme/rule.components buckets; the prewrite
     // gate consumes it to enforce uiComponentChoices presence and specReference
@@ -3022,18 +3241,20 @@ async function buildFrontendHybridDagFromTask(sources) {
                 outputContract: "Typed requirement facts plus a concise Markdown contract. Submit through the incremental typed tools record_requirement / record_constraint / record_evidence_expectation / record_handoff_intent / record_open_question / record_split_proposal / record_openspec_selection, then call finalize_contract exactly once. Requirements use stable REQ/BR/AC identifiers with source spans and a disposition (explicit | repository-resolvable | assumption | blocking); each requirement registers evidence expectations across static/behavior/Mock/real-integration (required | optional | not-applicable), and UI-visible or interactive requirements register a non-blocking frontend-test handoff intent. End finalize_contract with a single contract disposition of ready | ready-with-assumptions | blocked. Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations; do not fix target files, components, or implementation methods as requirements. When OpenSpec candidates exist, classify only the ones you actually use: call record_openspec_selection once per required/relevant path; never enumerate irrelevant candidates (unmentioned defaults to irrelevant) and never emit a fenced selection JSON. No file writes.",
                 subtask_prompt: [
                     "Read task source and produce a concise frontend implementation contract as typed requirement facts plus narrative Markdown.",
-                    "Assign each requirement a stable REQ/BR/AC identifier and a source span (task-source section or repository file:line). Label each requirement's disposition as explicit | repository-resolvable | assumption | blocking; a blocking requirement must name its owner (human-decision or external-state) and evidence refs.",
+                    "Assign each requirement the SAME id as the ledger canonical requirement it covers (sourceBinding.requirementIds, e.g. AC-001) — do NOT invent new REQ/BR prefixed ids for canonical requirements: the compiled contract must match the ledger canonical requirement ids exactly or schema validation rejects it (unknown requirement id). Requirements use the canonical id with a source span (task-source section or repository file:line). Label each requirement's disposition as explicit | repository-resolvable | assumption | blocking; a blocking requirement must name its owner (human-decision or external-state) and evidence refs.",
+                    "Source fidelity ledger: when the DAG sourceBinding carries a requirement→fragment mapping (requirementToFragments, e.g. REQ-SRC-* ids from the managed ledger), each record_requirement MUST declare the fragments that requirement is bound to: set sourceFragmentIds to the mapped fragment ids (the authoritative provenance evidence the design policy verifies). sourceRefs (fragment→path display refs) are optional — declare them only when you have the exact path from the materialized source; otherwise omit them rather than inventing paths. Declare exactly what the ledger binds — do not invent ids, do not omit them, and do not re-derive them from prose. A requirement that the ledger binds but the contract omits (or fabricates) fails writer admission.",
                     "Register evidence expectations for each requirement across static, behavior, Mock, and real integration as required | optional | not-applicable; required must follow from user requirements, task risk, or project governance, never from model convenience. For UI-visible or interactive requirements, register a non-blocking frontend-test handoff intent.",
                     "Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations. Do not fix target files, components, styling, or implementation methods as requirements; leave those to Scout and Plan.",
                     "If the task is too large for one bounded writer, record a task split proposal instead of silently widening scope.",
                     "End the contract with a single disposition: ready, ready-with-assumptions (bounded assumptions that do not change product behavior), or blocked.",
+                    scopedOpenspecContext,
                     ...(requiresOpenspecClassification ? [
                         "Classify OpenSpec candidates incrementally while contracting — only the ones you actually use. Call record_openspec_selection once per path with disposition required (must be read and cited by the plan) or relevant (may inform planning). Never call it for irrelevant candidates and never list them: candidates you do not mention are treated as irrelevant by the runtime. Explicit task declarations / source citations are already required and must-read regardless; you never need to re-declare them.",
                         "Mandatory paths are enforced by the runtime from the frozen task configuration — do not enumerate them, do not downgrade them.",
                         openspecSelectionContext,
                     ] : []),
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
-                    sourceContext,
+                    sourceContexts.contract,
                 ].join("\n\n"),
             },
             {
@@ -3053,7 +3274,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Report target surface and design evidence as facts (no fixed section title required): entrypoint, routeOrMount, implementationPaths, testPaths, dataSource, allowedPathConflicts. Use repository-relative POSIX paths. implementationPaths and testPaths must name the existing files/directories that actually own the requested behavior; allowedPathConflicts must list every discovered path not covered by task allowedPaths, or [] when none exists.",
                     "Derive all file paths from this target workspace. Do not assume the project uses src/, test/, React, or the loop-agent repository layout.",
                     "Read-only: do not modify repository files.",
-                    sourceContext,
+                    sourceContexts.scout,
+                    scopedOpenspecContext,
                 ].join("\n\n"),
             },
             {
@@ -3090,7 +3312,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                     verificationTargetFileInstruction,
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
                     fixedVerificationContext,
-                    sourceContext,
+                    sourceContexts.plan,
+                    scopedOpenspecContext,
                     mockContextBlock,
                     frontendContractSchemaBlock,
                     frontendComponentConformanceInstruction,
@@ -3166,6 +3389,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: "MED",
                 writePolicy: "read-only",
+                readBudget: FRONTEND_READ_BUDGETS.designReview,
+                retryPolicy: DEFAULT_READ_ONLY_PI_RETRY_POLICY,
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_DESIGN_REVIEW_SKILLS,
@@ -3177,11 +3402,13 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Your verdict is consumed only as deterministic data input by frontend-writer-admission-shell; it no longer drives any branch or gate. request_design_changes blocks writer admission (terminal).",
                     "Request design changes when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for a declared behavior target or selected Mock strategy. Mock strategies require Mock-backed evidence. A static-only contract is allowed only when every verification target is static and maps to a declared static entrypoint. not-needed otherwise requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
                     "Also request design changes for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
-                    "Component selection conformance is a hard blocking condition: request_design_changes when the frontend spec (component/theme/rule.components bucket) already defines a component for a purpose but the plan selects another or self-invents one without a declared deviation; when uiComponentChoices is missing/empty for UI-visible work while the frozen component/theme bucket is non-empty; or when any uiComponentChoices specReference.path is missing a ledger specReference or has no successful read event.",
+                    "Component selection conformance is a hard blocking condition: request_design_changes when the frontend spec (component/theme/rule.components bucket) already defines a component for a purpose but the plan selects another or self-invents one without a declared deviation; when uiComponentChoices is missing/empty for UI-visible work while the frozen component/theme bucket is non-empty; when a decision=specified specReference.path is missing a ledger OpenSpec reference or successful read event; or when a decision=new component lacks a traceable task-source/PRD specReference. A PRD reference for decision=new is not an OpenSpec citation and must not be rejected merely for lacking an OpenSpec read event.",
                     "You must NOT make authoritative assertions about the execution result of frozen verification commands (typecheck/test/build/lint/etc.). Predicting that a command will necessarily pass or fail, or declaring an acceptance criterion unreachable on that basis, is out of your authority: command results are deterministically established by frontend-verify-shell. Any concern about verification feasibility must be recorded only as a non-blocking verification concern in findings (severity must not be Critical, and it must never be the sole fatal basis for request_design_changes). Only semantic design defects (component selection, state flow, interaction contract, or conflicts with the specification) may be Critical. A pure command-will-fail prediction must not be classified as contract-requirement-gap.",
                     "Read-only: do not modify repository files.",
+                    "Canonical contract JSON: frontend-design-policy-shell prints its absolute output path in the upstream output (Contract: /abs/path/.harness/dag-runs/.../contracts/frontend-implementation-contract.json). Read exactly that path when you need the full contract — never resolve a bare contracts/... path against the repository root (it does not exist there), and do not hunt for substitutes. Implementation target files inside the writeSet (e.g. TaskSourceBadge.tsx or its test file) are created later by the implement node: do not read them and do not treat their absence as a design defect.",
                     fixedVerificationContext,
-                    sourceContext,
+                    sourceContexts.designReview,
+                    scopedOpenspecContext,
                     frontendContractFieldSummary,
                     mockContextBlock,
                 ].join("\n\n"),
@@ -3325,6 +3552,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: "HIGH",
                 writePolicy: "read-only",
+                readBudget: FRONTEND_READ_BUDGETS.finalReview,
                 retryPolicy: FRONTEND_REVIEW_TERMINAL_RETRY_POLICY,
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
@@ -3335,7 +3563,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Your authoritative terminal verdict is exactly one committed typed tool call: approve_review or request_review_changes. Call it once and do not call the other afterwards.",
                     "approve_review means the implementation passes; it must not carry Critical or Important findings. request_review_changes must carry a typed issueCategory, at least one evidenceRef, and non-empty findings.",
                     "Do NOT emit an equivalent JSON verdict in the response text: the committed typed terminal fact is the only authority and no branch or gate reads response-text JSON verdicts.",
-                    "Read contracts/frontend-review-context.json from frontend-review-context-shell. It binds the validated implementation contract, frontend lint assessment when lint is configured, the effective verification trace, and the run-owned actual diff (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
+                    "Read contracts/frontend-review-context.json from frontend-review-context-shell. It binds the validated implementation contract, frontend lint assessment when lint is configured, the effective verification trace, and the run-owned actual diff. Then read diff.reviewSummaryPath. The full artifacts/diff_patch.patch is retained only as audit evidence: do NOT read it in full. For semantic review, read only the named per-file diff fragment in the summary/index (in part order when needed) and then the current source file when necessary. Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
                     "Treat lint status exactly as passed | baseline-debt | failed | unavailable. baseline-debt may continue only with intact evidence and zero diagnostics on writer-changed files; report the tolerated debt count and never rewrite it as lint passed. Typecheck, build, and test still require successful final exits.",
                     "Flag .skip/.only, deleted or weakened tests, unauthorized config changes, Mock-only evidence claimed as real integration, and Browser/visual claims (always not-run in this workflow).",
                     "The contract embedded in frontend-review-context.json is the effective plan materialized by frontend-design-policy-shell. Do not re-open task sources, OpenSpec, AI workspace, design-review, writer summary, or verification node prose. Inspect only the canonical review context, its bound diff, and diff-referenced files when semantic review requires source code.",
@@ -3384,6 +3612,10 @@ async function buildFrontendHybridDagFromTask(sources) {
         ...(spec.advisories ?? []),
         `frontend-task-shape: ${frontendTaskShape.shape} (${frontendTaskShape.reason})`,
     ];
+    // Freeze the frontend recovery continuation quota from task.json so the
+    // runner can bound M6 auto-recovery without re-reading the task config.
+    const frontendMaxContinuations = sources.taskConfig.frontendRecovery?.maxContinuations ?? 1;
+    spec.frontendRecovery = { maxContinuations: frontendMaxContinuations };
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
@@ -6716,7 +6948,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" ||