@tea-agent/loop-agent 0.39.0-beta.0 → 0.39.0-beta.10

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";
@@ -8,10 +8,11 @@ import { DAG_AGENT_RUNTIME_PI_ONLY, DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1,
 import { bindDagRerunFeedback } from "./rerun-feedback.js";
 import { planMavenVerification, } from "../../verification/maven/index.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
-import { extractTaskSourceOpenspecPaths } from "../../shared/openspec-spec.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, STRUCTURED_REQUIRED_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, WRITER_TRANSPORT_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate, isWriterTransportRetryCandidate, } from "./retry-policy.js";
+import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, FRONTEND_SCOUT_COMPLETENESS_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";
 import { REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL, REVIEW_VERDICT_OUTPUT_PROTOCOL, } from "./output-protocol.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
@@ -19,22 +20,28 @@ import { mergeDocumentIndexCompanions } from "../../governance/document-index-cl
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
 import { applySddEmbeddedEnhancements, probeRepoLocalSddSkills, } from "./sdd-embedded.js";
 import { discoverProjectGovernancePresence } from "./project-governance-context.js";
-import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
+import { CANONICAL_TASK_ID_PATTERN, getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { materializeTaskReferenceDocs } from "../../task/source-references.js";
-import { REQUIREMENT_FACT_ROLES } from "../../task/source-prepare/artifact-meta.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";
 import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "./task-demand-routing.js";
 import { BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT, buildBackendTestExecutionPreflightShellSnippet, } from "./backend-test-execution-contract.js";
 import { resolveBackendTestLayout, } from "./backend-test-layout.js";
+import { applyFrontendTestLayoutToText, resolveFrontendTestLayout, } from "./frontend-test-layout.js";
 import { buildBackendTestOutcomeGateShellSnippet } from "./backend-test-result-contract.js";
 import { buildBackendTestIntakeContext } from "./backend-test-intake-context.js";
 import { buildFrontendTestOutcomeGateShellSnippet } from "./frontend-test-result-contract.js";
 import { classifyFrontendRisk, } from "./frontend-risk.js";
-import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
-import { buildFrontendImplementationContractSkeleton, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, FRONTEND_IMPLEMENTATION_CONTRACT_PLAN_PATCH_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } from "./frontend-implementation-contract.js";
+import { discoverFrontendProjectCapability, resolveFrontendSpecRootAliases, } from "./frontend-project-capability.js";
+import { buildFrontendImplementationContractSkeleton, } from "./frontend-implementation-contract.js";
+import { computeFrontendShapeSourceDigest, parseFrontendShapeTransitionCapsule, resolveFrontendTaskShape, } from "./frontend-shape.js";
+import { discoverLatestCommittedFrontendShapeCapsule } from "./frontend-shape-capsule-store.js";
+import { FRONTEND_NO_VERIFICATION_MARKER_TEXT } from "./frontend-verification-trace.js";
 import { serializeDagTaskSourcePath } from "../../task/dag-source-paths.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
@@ -100,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: 512 * 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
@@ -216,6 +230,28 @@ async function hasDirectDependency(repoRoot, depName) {
         return false;
     }
 }
+/**
+ * Collect the project's declared direct dependencies (dependencies +
+ * devDependencies names) from package.json. Used to freeze the frontend
+ * design-policy allowedDependencies set: the model's dependency policy must
+ * not be rejected for mentioning an already-declared dependency, and a
+ * dependency not present in the manifest is a genuine unauthorized addition.
+ * Returns [] when package.json is unreadable (no allowlist → the dependency
+ * check is skipped rather than rejecting prose tokens).
+ */
+async function collectDeclaredDependencies(repoRoot) {
+    try {
+        const raw = await readFile(path.join(repoRoot, "package.json"), "utf-8");
+        const pkg = JSON.parse(raw);
+        return [
+            ...Object.keys(pkg.dependencies ?? {}),
+            ...Object.keys(pkg.devDependencies ?? {}),
+        ];
+    }
+    catch {
+        return [];
+    }
+}
 /** Check whether handler/fixture/bootstrap files exist for known mock frameworks. */
 async function discoverMockHandlerFiles(repoRoot, serviceRoot) {
     const exactCandidates = [
@@ -1282,11 +1318,15 @@ function deriveParallelScoutPaths(taskConfig) {
                 : allowed,
     };
 }
+const FRONTEND_NO_STATIC_VERIFICATION_MARKER = `node -e "console.log('${FRONTEND_NO_VERIFICATION_MARKER_TEXT}; static/behavior verification not-run')"`;
 /**
  * Resolve frontend verification fallbacks from the target project's own
  * package scripts. The DAG builder is also used by unit fixtures without a
- * package.json, so those fixtures retain the historical generic fallback.
- * Real projects never inherit loop-agent's commands when package.json exists.
+ * repoRoot, so those fixtures retain the historical generic fallback. A real
+ * project (repoRoot set) without a readable package.json has no scripts to
+ * invoke; the generic fallback would only inject commands guaranteed to fail
+ * at verify time, so such projects fall through to the tsc probe and may end
+ * up with no fallback commands plus a generation-time advisory.
  */
 async function discoverFrontendFallbackVerifyCommands(repoRoot) {
     const genericFallback = {
@@ -1303,10 +1343,8 @@ async function discoverFrontendFallbackVerifyCommands(repoRoot) {
         }
     }
     catch {
-        return genericFallback;
+        // No readable manifest: leave scripts unset and keep probing.
     }
-    if (!scripts)
-        return genericFallback;
     let packageManager = "npm";
     for (const [lockfile, manager] of [
         ["pnpm-lock.yaml", "pnpm"],
@@ -1383,19 +1421,66 @@ function toDagSourcePath(sources, absolutePath) {
         absolutePath,
     });
 }
-function extractExplicitRequirementIds(...markdownInputs) {
+/**
+ * Declaration-line shapes that assert a requirement id: list items
+ * ("- AC-1: ..."), numbered/ordered acceptance entries ("1. AC-1 ...",
+ * "1、AC-1"), table rows ("| AC-1 | ..."), and explicit key/value or
+ * heading declarations ("AC-1：...", "id: AC-1"). Ids that merely appear
+ * inside narrative prose (e.g. a fixture run id mentioned in background:
+ * "夹具 run 2026-08-23-req-f03535aa 已存在") are incidental mentions, not
+ * declared requirements, and must not pollute sourceBinding.requirementIds.
+ */
+const REQUIREMENT_ID_DECLARATION_LINE = /^\s*(?:[-+*]\s+|\d+[.、)）]\s*|\|\s*)?(?:[-A-Z0-9]+\s*[::]\s*)?(?:\*\*)?(?:REQ|BR|AC)-/i;
+function isRequirementIdDeclarationLine(line) {
+    return REQUIREMENT_ID_DECLARATION_LINE.test(line);
+}
+function extractExplicitRequirementIds(requirementMarkdown, ...fallbackMarkdown) {
     const ids = [];
     const seen = new Set();
-    for (const markdown of markdownInputs) {
+    const collect = (markdown, declarationsOnly) => {
         if (!markdown)
-            continue;
-        for (const match of markdown.matchAll(/\b(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/gi)) {
+            return;
+        const source = declarationsOnly
+            ? markdown
+                .split(/\r?\n/)
+                .filter((line) => isRequirementIdDeclarationLine(line))
+                .join("\n")
+            : markdown;
+        for (const match of source.matchAll(/\b(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/gi)) {
             const id = match[0].toUpperCase();
             if (!seen.has(id)) {
                 seen.add(id);
                 ids.push(id);
             }
         }
+    };
+    // The requirement document itself is human-authored acceptance prose:
+    // only declaration lines declare requirements there. If the document has
+    // no declaration-shaped lines at all (minimal free-form tasks like
+    // "covers AC-001"), fall back to its full text so bindings never go
+    // missing for unstructured input. References and constraints are bound
+    // documents (acceptance yaml, analysis docs) whose ids are authoritative
+    // wherever they appear — keep full scan for them.
+    const declarationLines = requirementMarkdown
+        .split(/\r?\n/)
+        .filter((line) => isRequirementIdDeclarationLine(line));
+    collect(requirementMarkdown, declarationLines.length > 0);
+    for (const markdown of fallbackMarkdown) {
+        if (markdown)
+            collect(markdown, false);
+    }
+    return ids;
+}
+/** Extract ids from an explicit authoritative section (full scan inside it). */
+function extractSectionRequirementIds(sectionMarkdown) {
+    const ids = [];
+    const seen = new Set();
+    for (const match of sectionMarkdown.matchAll(/\b(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/gi)) {
+        const id = match[0].toUpperCase();
+        if (!seen.has(id)) {
+            seen.add(id);
+            ids.push(id);
+        }
     }
     return ids;
 }
@@ -1409,7 +1494,7 @@ export function extractTaskScopedRequirementIds(requirementMarkdown, ...fallback
     // Without it, preserve legacy full-scan behavior (requirement + references).
     const sectionMatch = requirementMarkdown.match(/(?:^|\n)##\s*Acceptance References\s*\n([\s\S]*?)(?=\n##\s+|\n#\s+|$)/i);
     if (sectionMatch?.[1]) {
-        const fromSection = extractExplicitRequirementIds(sectionMatch[1]);
+        const fromSection = extractSectionRequirementIds(sectionMatch[1]);
         if (fromSection.length > 0)
             return fromSection;
     }
@@ -1427,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",
@@ -1462,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");
@@ -1478,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,
@@ -1487,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);
@@ -1495,34 +1701,20 @@ 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, "/");
         const referenceRef = toDagSourcePath(sources, reference.path);
-        // Fact-source roles (requirement/acceptance) carry the fields contracts
-        // depend on (AC/scope/columns). Inject them in full so a fixed excerpt
-        // cannot silently drop definitions; archival roles stay excerpted.
-        const isFactRole = reference.role !== undefined &&
-            REQUIREMENT_FACT_ROLES.has(reference.role);
-        const referenceExcerpt = isFactRole
-            ? {
-                text: reference.markdown.trim(),
-                truncated: false,
-                originalChars: reference.markdown.trim().length,
-                maxChars: Number.POSITIVE_INFINITY,
-            }
-            : excerptMarkdown(reference.markdown, {
-                sourceRef: referenceRef,
-            });
-        boundReadPaths.push(`- reference ${relativePath}${isFactRole ? " (full source)" : ""}: ${referenceRef}`);
-        parts.push(`## Task source reference: ${relativePath}`, `Bound readPath (use for Pi read-tool calls): ${referenceRef}`, ...(isFactRole
-            ? [
-                `Full source injected (role: ${reference.role}) — complete and authoritative; no excerpt truncation applied.`,
-            ]
-            : []), referenceExcerpt.text);
+        const referenceExcerpt = excerptMarkdown(reference.markdown, {
+            sourceRef: referenceRef,
+        });
+        boundReadPaths.push(`- reference ${relativePath}: ${referenceRef}`);
+        parts.push(`## Task source reference: ${relativePath}`, `Bound readPath (use for Pi read-tool calls): ${referenceRef}`, referenceExcerpt.text);
     }
     parts.push("## Bound source read paths", ...boundReadPaths, "Use these repository-readable paths for any Pi read-tool calls. Bound files under `.harness/tasks/<taskId>/source/**` are read-only inputs: reading them is allowed even though writing `.harness/**` is forbidden.", "Never resolve task-relative citations such as `source/需求.md` or `source/references/*` against the repository root, invent `source/<taskId>/...`, search for substitutes, or fall back to `docs/**` when a bound read fails.", "## Task config summary", `- taskId: ${sources.taskConfig.taskId}`, `- flow: ${sources.taskConfig.flow}`, `- complexity: ${sources.taskConfig.complexity}`, `- contextProfile: ${sources.taskConfig.contextProfile}`, `- allowedPaths: ${sources.taskConfig.allowedPaths.join(", ") || "(none — review before execute)"}`, `- forbiddenPaths: ${sources.taskConfig.forbiddenPaths.join(", ") || "(none)"}`, '- Pi DAG nodes are read-only unless toolProfile="write" is explicitly selected for a bounded writer node.', "- Agent DAG read-only nodes must not write root artifacts/**; root artifacts/ is not a per-node scratchpad.", `- Derived execution contract and immutable references live under the Bound source read paths above (not as repo-root \`source/...\`).`);
     if (sources.taskConfig.hardConstraints.length > 0) {
@@ -1560,49 +1752,10 @@ async function loadMaterializedSourceReferences(sourceDir) {
     }
     await collect(referenceDir);
     referencePaths.sort((left, right) => left.localeCompare(right));
-    const roleByPath = await loadReferenceRoles(sourceDir);
-    return Promise.all(referencePaths.map(async (filePath) => {
-        const relative = path
-            .relative(sourceDir, filePath)
-            .replaceAll(path.sep, "/");
-        const role = roleByPath.get(relative);
-        return {
-            path: filePath,
-            markdown: await readFile(filePath, "utf-8"),
-            ...(role !== undefined ? { role } : {}),
-        };
-    }));
-}
-/**
- * Reads `source-manifest.json` into a materializedPath → role map so the DAG
- * generator can tell fact-source references (requirement/acceptance) apart
- * from archival ones (analysis/clarification/design). A missing or malformed
- * manifest yields an empty map; such references keep the bounded-excerpt
- * treatment instead of being injected in full.
- */
-async function loadReferenceRoles(sourceDir) {
-    const roleByPath = new Map();
-    const manifestPath = path.join(sourceDir, "source-manifest.json");
-    let raw;
-    try {
-        raw = await readFile(manifestPath, "utf-8");
-    }
-    catch {
-        return roleByPath;
-    }
-    try {
-        const manifest = JSON.parse(raw);
-        for (const document of manifest.documents ?? []) {
-            if (typeof document.materializedPath === "string" &&
-                typeof document.role === "string") {
-                roleByPath.set(document.materializedPath.replaceAll(path.sep, "/"), document.role);
-            }
-        }
-    }
-    catch {
-        // A malformed manifest must never break reference injection.
-    }
-    return roleByPath;
+    return Promise.all(referencePaths.map(async (filePath) => ({
+        path: filePath,
+        markdown: await readFile(filePath, "utf-8"),
+    })));
 }
 export async function loadTaskHybridSources(repoRoot, taskId) {
     const paths = getTaskPaths(repoRoot, taskId);
@@ -1683,6 +1836,16 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
     catch (error) {
         throw new Error(`failed to load verification commands for task "${taskId}": ${error instanceof Error ? error.message : String(error)}`);
     }
+    const frontendShapeTransitionCapsule = taskConfig.taskKind === "frontend-implementation" && CANONICAL_TASK_ID_PATTERN.test(taskId)
+        ? await discoverLatestCommittedFrontendShapeCapsule({
+            repoRoot,
+            taskId,
+            sourceDigest: computeFrontendShapeSourceDigest({
+                requirementMarkdown,
+                constraintMarkdown: constraintMarkdown ?? "",
+            }),
+        })
+        : undefined;
     const sources = {
         taskId,
         repoRoot,
@@ -1699,6 +1862,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         verifyCommands,
         sddEmbeddedSkills: await probeRepoLocalSddSkills(repoRoot),
         projectGovernancePresent: await discoverProjectGovernancePresence(repoRoot),
+        ...(frontendShapeTransitionCapsule ? { autoloadedFrontendShapeTransitionCapsule: frontendShapeTransitionCapsule } : {}),
     };
     return sources;
 }
@@ -1716,7 +1880,9 @@ async function prepareFrontendMockSources(sources, discoveredProjectCapability)
         }
     }
     const projectCapability = discoveredProjectCapability ??
-        (await discoverFrontendProjectCapability(repoRoot));
+        (await discoverFrontendProjectCapability(repoRoot, {
+            specRoots: sources.taskConfig.frontendOpenspec?.specRoots,
+        }));
     const frontendRisk = classifyFrontendRisk({
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
@@ -1775,6 +1941,7 @@ export function buildStandardHybridDagFromTask(sources) {
                 forbiddenPaths,
                 outputContract: "Archived final shell verification stdout/stderr with exit codes; no worktree writes.",
                 subtask_prompt: "Run the adapter-resolved final verification commands before read-only verification review.",
+                transientRetryProfile: TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE,
                 shell: {
                     commands: verifyShellCommands,
                     verifyEvidence: buildVerifyEvidence({
@@ -1826,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.",
@@ -1842,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.",
@@ -1858,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.",
@@ -1895,6 +2065,7 @@ export function buildStandardHybridDagFromTask(sources) {
                 allowedPaths: implementPaths.allowedPaths,
                 forbiddenPaths,
                 writerOutcomePolicy: { type: "implementation-outcome-v1" },
+                transientRetryProfile: TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE,
                 subtask_prompt: [
                     "Implement the approved plan with minimal focused changes.",
                     "Stay within writeSet. Do not write root artifacts/** unless artifacts paths are explicitly declared in writeSet.",
@@ -1954,6 +2125,7 @@ export function buildStandardHybridDagFromTask(sources) {
         ],
     };
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    stampTargetTemplateTransientRetryProfile(spec);
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
@@ -2222,40 +2394,180 @@ function frontendMockStrategyMustBeNotNeeded(sources) {
             capabilityStatus === "ambiguous" ||
             !hasDeterministicMockVerification));
 }
-function resolveFrontendOpenspecGateConfig(sources) {
+/**
+ * 候选规范懒加载：prompt 只内联与任务相关的候选，不全部塞给模型。
+ *
+ * - mandatory（任务源显式声明/引用）始终保留——模型必须知道它们存在。
+ * - scan-strict 候选按「路径段是否命中任务源关键词」过滤：列表页任务只
+ *   带出列表相关组件/页面规范，创建页规范不进 prompt。
+ * - runtime 的选型/read 门禁仍消费完整 openspecCandidatePaths（prewrite
+ *   gate 用全量）；这里只缩小 prompt 体积，不改变门禁语义。未提及的候选
+ *   由 runtime 默认 irrelevant，模型无需枚举。
+ * - 真正读取发生在 plan 侧：模型对 required 选型调用 read 工具，prewrite
+ *   门禁验证 read 事件——按需读取，不预加载正文。
+ */
+export function filterRelevantOpenspecCandidates(input) {
+    const mandatory = new Set(input.mandatoryPaths);
+    const relevant = [];
+    for (const candidate of input.candidates) {
+        if (mandatory.has(candidate)) {
+            relevant.push(candidate);
+            continue;
+        }
+        if (openspecCandidateMatchesSource(candidate, input.sourceMarkdown)) {
+            relevant.push(candidate);
+        }
+    }
+    // 保持候选发现顺序（确定性）；mandatory 与相关候选都按原始顺序出现。
+    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（去扩展名、
+ * 去连字符/下划线），若候选的路径段包含任一 token 即视为相关。纯字符串
+ * 判定，无 IO；找不到 token 时保守保留（避免漏掉模型可能需要的规范）。
+ */
+function openspecCandidateMatchesSource(candidate, sourceMarkdown) {
+    const sourceTokens = extractOpenspecSourceTokens(sourceMarkdown);
+    if (sourceTokens.size === 0)
+        return true;
+    const candidateLower = candidate.toLowerCase().replace(/\\/g, "/");
+    const candidateSegments = candidateLower.split("/");
+    const candidateBasename = candidateSegments[candidateSegments.length - 1] ?? "";
+    for (const token of sourceTokens) {
+        if (candidateBasename.includes(token) ||
+            candidateLower.includes(`/${token}/`) ||
+            candidateLower.includes(`${token}.`)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** 从任务源 markdown 提取显著 token：反引号代码段、路径、组件/页面名。 */
+function extractOpenspecSourceTokens(markdown) {
+    const tokens = new Set();
+    const push = (raw) => {
+        const cleaned = raw
+            .trim()
+            .replace(/[.*+?^${}()|[\]\\]/g, "")
+            .toLowerCase();
+        if (cleaned.length >= 2 && cleaned.length <= 40)
+            tokens.add(cleaned);
+    };
+    // 反引号内联代码（文件名/组件名）
+    for (const match of markdown.matchAll(/`([^`\n]+)`/g)) {
+        push(match[1] ?? "");
+    }
+    // markdown 链接文本
+    for (const match of markdown.matchAll(/\[([^\]]+)\]\([^)]+\)/g)) {
+        push(match[1] ?? "");
+    }
+    // 路径 token（openspec/ 或 xxx/xxx.md）
+    for (const match of markdown.matchAll(/(?:[A-Za-z0-9_-]+\/)+[A-Za-z0-9_.-]+/g)) {
+        const segments = (match[0] ?? "").split("/");
+        const basename = segments[segments.length - 1] ?? "";
+        push(basename.replace(/\.[a-z0-9]+$/i, ""));
+        for (const segment of segments)
+            push(segment);
+    }
+    return tokens;
+}
+async function resolveFrontendOpenspecGateConfig(sources) {
     const taskConfig = sources.taskConfig;
     const policy = taskConfig.frontendOpenspec?.policy ?? "cited";
     const declared = taskConfig.frontendOpenspec?.requiredReadPaths ?? [];
-    const taskSourceCited = extractTaskSourceOpenspecPaths([sources.requirementMarkdown, sources.constraintMarkdown ?? ""].join("\n"));
+    const governanceRoot = sources.frontendProjectCapability?.openspecDiscovery?.governanceRoot ??
+        DEFAULT_OPENSPEC_GOVERNANCE_ROOT;
+    const specRoots = taskConfig.frontendOpenspec?.specRoots ?? DEFAULT_FRONTEND_SPEC_ROOTS;
+    const rootAliases = sources.repoRoot
+        ? await resolveFrontendSpecRootAliases(sources.repoRoot, [...specRoots])
+        : [];
+    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),
         taskSourceCited: dedupeSorted(taskSourceCited),
         scanStrict: dedupeSorted(scanStrict),
     };
+    // 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,
+    ]);
+    // `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"
-        ? dedupeSorted([...declared, ...taskSourceCited])
-        : openspecCandidateSources.scanStrict;
-    return {
+        ? 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) => ({
+            path: candidate,
+            sha256: createHash("sha256")
+                .update(await readFile(path.join(sources.repoRoot, candidate)))
+                .digest("hex"),
+        })));
+    }
+    return result;
 }
-const openspecCitationInstruction = [
-    "OpenSpec 引用块（citation block）：在 fenced json 契约块之后，追加**恰好一个** ```openspec-citations 围栏代码块（三反引号 + openspec-citations）。",
-    '该块内每行一个 JSON 对象 {"path":"<repo 相对 openspec 路径>","section":"<命中章节或空串>","line":<int 或 null>}，必须逐条列出你在本计划中实际读取并应用的每个 openspec 规范文件。',
-    "prewrite gate 会用真实 read 事件核验每条引用：引用存在但无成功 read 事件 → openspec-citation-not-read；契约冻结的必读候选未被引用 → openspec-not-cited；两者都 fail-closed。不要引用未读取的路径。",
-].join("\n");
 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；未在 openspec-citations 引用块中引用或未真实读取 → 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;
@@ -2269,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(", ")})`
@@ -2305,17 +2590,102 @@ function resolveFrontendCapabilityContextBlock(sources) {
     }
     return parts.join("\n");
 }
+function pruneFrontendTasksForMicro(tasks) {
+    // Micro topology (7 nodes): contract-import-shell → writer-admission →
+    // implement → verify → review-context → review → closeout. Drops scout/plan/
+    // design-policy/design-review and replaces the model contract node with a
+    // deterministic contract-import shell (§7.3: no model, no requirement
+    // rewrites — micro consumes a pre-validated managed Contract).
+    const drop = new Set([
+        "frontend-contract-pi",
+        "frontend-scout-pi",
+        "frontend-plan-pi",
+        "frontend-design-policy-shell",
+        "frontend-design-review-pi",
+    ]);
+    const contractPi = tasks.find((task) => task.id === "frontend-contract-pi");
+    const contractImportShell = contractPi
+        ? {
+            id: "frontend-contract-import-shell",
+            role: "verifier",
+            executor: "shell",
+            complexity: "LOW",
+            writePolicy: "read-only",
+            depends_on: [],
+            allowedPaths: contractPi.allowedPaths,
+            forbiddenPaths: contractPi.forbiddenPaths,
+            subtask_prompt: "Deterministic managed-Contract import + source/binding/schema freshness re-validation; no model, no requirement rewrite.",
+            shell: {
+                commands: [],
+                frontendContractImport: {
+                    schemaVersion: 1,
+                    artifactName: "frontend-task-contract.json",
+                    outputDir: "contracts",
+                    requireSourceFreshness: true,
+                },
+                cwd: ".",
+                timeoutMs: 60000,
+            },
+        }
+        : undefined;
+    const filtered = [
+        ...(contractImportShell ? [contractImportShell] : []),
+        ...tasks.filter((task) => !drop.has(task.id)),
+    ];
+    const byId = new Map(filtered.map((task) => [task.id, task]));
+    const remap = (deps) => {
+        if (!deps)
+            return [];
+        const next = [];
+        for (const dep of deps) {
+            if (drop.has(dep))
+                continue;
+            if (byId.has(dep))
+                next.push(dep);
+        }
+        return [...new Set(next)];
+    };
+    return filtered.map((task) => {
+        const depends_on = remap(task.depends_on);
+        if (task.id === "frontend-writer-admission-shell") {
+            const admission = task.shell?.frontendWriterAdmission;
+            return {
+                ...task,
+                depends_on: ["frontend-contract-import-shell"],
+                shell: admission
+                    ? {
+                        ...task.shell,
+                        commands: task.shell?.commands ?? [],
+                        frontendWriterAdmission: {
+                            ...admission,
+                            designReviewFromNodeId: undefined,
+                        },
+                    }
+                    : task.shell,
+            };
+        }
+        return { ...task, depends_on };
+    });
+}
+function pruneFrontendTasksForSplitRequired(tasks) {
+    const writerChain = new Set([
+        "frontend-writer-admission-shell",
+        "frontend-implement-pi",
+        "frontend-verify-shell",
+        "frontend-review-context-shell",
+        "frontend-review-pi",
+        "frontend-closeout-shell",
+    ]);
+    return tasks.filter((task) => !writerChain.has(task.id));
+}
 function pruneFrontendTasksForRisk(tasks, risk) {
     if (risk.forceFullGates || risk.selectedRisk !== "small") {
         return tasks;
     }
-    // Small topology keeps one design review and removes only the conditional
-    // revision/final-review branch. The deterministic prewrite gate consumes the
-    // surviving plan and design review directly.
-    const drop = new Set([
-        "frontend-plan-revision-pi",
-        "frontend-final-design-review-pi",
-    ]);
+    // Small topology keeps one design review and removes only the redundant
+    // design-review node; the deterministic design-policy and writer-admission
+    // shells consume the surviving plan directly.
+    const drop = new Set(["frontend-design-review-pi"]);
     const filtered = tasks.filter((task) => !drop.has(task.id));
     const byId = new Map(filtered.map((task) => [task.id, task]));
     const remap = (deps) => {
@@ -2323,11 +2693,8 @@ function pruneFrontendTasksForRisk(tasks, risk) {
             return [];
         const next = [];
         for (const dep of deps) {
-            if (dep === "frontend-plan-revision-pi") {
-                if (byId.has("frontend-plan-pi"))
-                    next.push("frontend-plan-pi");
+            if (dep === "frontend-design-review-pi")
                 continue;
-            }
             if (byId.has(dep) || dep === "frontend-implement-pi")
                 next.push(dep);
         }
@@ -2335,30 +2702,27 @@ function pruneFrontendTasksForRisk(tasks, risk) {
     };
     return filtered.map((task) => {
         const depends_on = remap(task.depends_on);
-        if (task.id === "frontend-prewrite-gate-shell") {
-            const gate = task.shell?.frontendPrewriteGate;
+        if (task.id === "frontend-writer-admission-shell") {
+            // Small topology: no design review node, so the admission shell drops
+            // the design-review dependency and the verdict requirement.
+            const admission = task.shell?.frontendWriterAdmission;
             return {
                 ...task,
-                depends_on: ["frontend-plan-pi", "frontend-design-review-pi"],
-                dependsPolicy: "all",
-                shell: gate
+                depends_on: ["frontend-design-policy-shell"],
+                shell: admission
                     ? {
                         ...task.shell,
                         commands: task.shell?.commands ?? [],
-                        frontendPrewriteGate: {
-                            ...gate,
-                            planFromNodeId: "frontend-plan-pi",
-                            planFallbackFromNodeIds: [],
-                            reviewFromNodeId: "frontend-design-review-pi",
-                            reviewFallbackFromNodeIds: [],
-                            revisionPatch: false,
+                        frontendWriterAdmission: {
+                            ...admission,
+                            designReviewFromNodeId: undefined,
                         },
                     }
                     : task.shell,
             };
         }
         if (task.id === "frontend-implement-pi") {
-            for (const need of ["frontend-prewrite-gate-shell"]) {
+            for (const need of ["frontend-writer-admission-shell"]) {
                 if (byId.has(need) && !depends_on.includes(need))
                     depends_on.push(need);
             }
@@ -2383,9 +2747,23 @@ function buildFrontendWriterNodeDefaults(input) {
         allowedPaths: input.allowedPaths,
         forbiddenPaths: input.forbiddenPaths,
         skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
-        writerOutcomePolicy: { type: "implementation-outcome-v1" },
+        writerOutcomePolicy: {
+            type: input.writerOutcomePolicyType ?? "implementation-outcome-v1",
+        },
     };
 }
+function resolveFrontendShapeCapsuleGenerationInput(sources) {
+    const explicit = sources.frontendShapeTransitionCapsule == null
+        ? undefined
+        : parseFrontendShapeTransitionCapsule(sources.frontendShapeTransitionCapsule);
+    const autoloaded = sources.autoloadedFrontendShapeTransitionCapsule == null
+        ? undefined
+        : parseFrontendShapeTransitionCapsule(sources.autoloadedFrontendShapeTransitionCapsule);
+    if (explicit && autoloaded && explicit.capsuleDigest !== autoloaded.capsuleDigest) {
+        throw new Error("explicit frontend shape transition capsule conflicts with runtime autoload");
+    }
+    return explicit ?? autoloaded;
+}
 async function buildFrontendHybridDagFromTask(sources) {
     const { taskConfig } = sources;
     const mockCapability = sources.frontendMockCapability ?? {
@@ -2410,6 +2788,11 @@ async function buildFrontendHybridDagFromTask(sources) {
     const implementId = frontendImplementationNodeId();
     const mockContextBlock = resolveFrontendMockContextBlock(frontendSources);
     const capabilityContextBlock = resolveFrontendCapabilityContextBlock(frontendSources);
+    // Freeze the design-policy dependency allowlist from the project manifest:
+    // already-declared deps are authorized; anything else in the model's
+    // dependency policy that looks like a package name is an unauthorized new
+    // dependency (fail-closed at the policy shell and the plan pre-check).
+    const declaredDependencies = await collectDeclaredDependencies(sources.repoRoot ?? process.cwd());
     const frontendRisk = frontendSources.frontendRisk ??
         classifyFrontendRisk({
             title: taskConfig.title,
@@ -2418,150 +2801,63 @@ async function buildFrontendHybridDagFromTask(sources) {
             allowedPaths: taskConfig.allowedPaths,
             complexity: taskConfig.complexity,
         });
-    const frontendSourceBinding = buildDagSourceBinding(sources);
+    const frontendTaskShape = resolveFrontendTaskShape({
+        complexity: taskConfig.complexity,
+        allowedPaths: taskConfig.allowedPaths,
+        requirementMarkdown: sources.requirementMarkdown,
+        constraintMarkdown: sources.constraintMarkdown ?? undefined,
+        splitSignal: { splitRequired: false, runtimeSupportsSplit: true },
+        taskId: sources.taskId,
+        sourceDigest: computeFrontendShapeSourceDigest({
+            requirementMarkdown: sources.requirementMarkdown,
+            constraintMarkdown: sources.constraintMarkdown ?? "",
+        }),
+        shapeTransitionCapsule: resolveFrontendShapeCapsuleGenerationInput(sources),
+    });
+    const frontendSourceBinding = buildDagSourceBinding(sources, taskConfig.taskKind);
     const frontendContractSkeleton = buildFrontendImplementationContractSkeleton({
         sourceBinding: frontendSourceBinding,
         riskLevel: frontendRisk.selectedRisk,
         targetFiles: implementPaths.writeSet,
     });
-    const frontendContractSchemaBlock = (() => {
-        const schema = loadFrontendImplementationContractJsonSchema();
-        return [
-            `## Final ${FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID} JSON Schema (authoritative after runtime merge)`,
-            schema,
-            "",
-            "## Runtime contract skeleton (deterministic and protected)",
-            JSON.stringify(frontendContractSkeleton),
-            "",
-            "The initial planner emits an editable RFC 7386 patch against this skeleton. It MUST omit schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. The runtime merges and validates the final contract, then replaces the planner output with canonical full-contract JSON for downstream review.",
-            "",
-            "## Forbidden fields (these are NOT in the schema; do not emit)",
-            "- schemaId",
-            "- targetFiles",
-            "- requirementCoverage",
-            "",
-            "## Critical rules",
-            "- verificationTargets is a TOP-LEVEL required array",
-            "- uiStates items use name/applicable/expectedBehavior/implementationTargets/verificationTargetIds/notApplicableReason",
-            "- 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)",
-            "- All implementation files, verification files, symbols, and commands must be discovered from the current target workspace and current task. Never copy paths, symbols, or commands from the loop-agent repository, an example task, or prior run output.",
-            "- Use relative POSIX paths rooted at the target workspace. Do not assume a particular src/test directory layout; preserve the target project's actual app/, packages/, spec/, __tests__, or other layout.",
-            "",
-            "## Bad / Good contract field examples",
-            "",
-            "### 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',
-            "",
-            '### verificationTargets - GOOD (real frozen label, real file):',
-            '{"id":"vt-1","type":"static","commandLabel":"npm run typecheck","file":"tsconfig.json","requirementIds":["AC-001"],"uiStates":[]}  <-- Matches frozen command set; real file path',
-            "",
-            "### requirements - BAD (missing expectedOutcome):",
-            '{"id":"AC-001","expectedOutcome":"","implementationTargets":["src/app.tsx"],"verificationTargetIds":["vt-1"]}  <-- REJECTED: empty expectedOutcome',
-            "",
-            "### requirements - GOOD (concrete expectedOutcome):",
-            '{"id":"AC-001","expectedOutcome":"TypeScript compilation exits with code 0 and produces no errors in dist/","implementationTargets":["src/app.tsx"],"verificationTargetIds":["vt-1"]}',
-            "",
-            "### interactions - BAD (empty trigger/expectedBehavior):",
-            '{"name":"save-click","trigger":"","expectedBehavior":"","implementationTargets":["src/button.tsx"],"verificationTargetIds":["vt-3"]}  <-- REJECTED: empty trigger and expectedBehavior',
-            "",
-            "### interactions - GOOD:",
-            '{"name":"save-click","trigger":"User clicks the Save button in the editor toolbar","expectedBehavior":"POST /api/save is called with editor content; success toast appears; button enters disabled+spinner state until response","implementationTargets":["src/editor/save-button.tsx"],"verificationTargetIds":["vt-3"]}',
-            "",
-            "### uiStates - BAD (applicable=true but missing expectedBehavior):",
-            '{"name":"loading","applicable":true,"expectedBehavior":"","implementationTargets":[],"verificationTargetIds":[]}  <-- REJECTED: applicable UI state requires non-empty expectedBehavior, implementationTargets, and verificationTargetIds',
-            "",
-            "### uiStates - GOOD (applicable=true with complete fields):",
-            '{"name":"loading","applicable":true,"expectedBehavior":"Skeleton placeholder visible while data fetches; aria-busy=true on the list container","implementationTargets":["src/dashboard/list-view.tsx"],"verificationTargetIds":["vt-3"]}',
-            "",
-            "### uiStates - BAD (applicable=false without notApplicableReason):",
-            '{"name":"dark-mode","applicable":false}  <-- REJECTED: non-applicable UI state requires notApplicableReason',
-            "",
-            "### uiStates - GOOD (applicable=false with reason):",
-            '{"name":"dark-mode","applicable":false,"notApplicableReason":"Dark mode toggle is out of scope for this task; only light theme is targeted"}',
-            "",
-            "### mockApi.endpoints - BAD (strategy=native but empty endpoints):",
-            '{"strategy":"native","productionDefaultOff":true,"activation":"env flag","endpoints":[]}  <-- REJECTED: native strategy requires at least one endpoint with method, path, fixture, and consumer',
-            "",
-            "### mockApi.endpoints - GOOD (strategy=native with complete endpoint):",
-            '{"strategy":"native","productionDefaultOff":true,"activation":"VITE_ENABLE_MOCK=true","endpoints":[{"method":"GET","path":"/api/users","fixture":"mocks/fixtures/users.json","consumer":"src/api/users.ts"}]}',
-            "",
-            "### optional plan fields - GOOD (all optional; omit when absent):",
-            '{"implementationSteps":["confirm contract","sync tests"],"stylingStrategy":"reuse existing design tokens","dependencyPolicy":"no new runtime deps","residualRisks":["browser a11y not-run"],"realIntegrationGap":"FE-TEST owns live HTTP"}',
-            "",
-            "### optional plan fields - BAD (present-but-empty strings are rejected):",
-            '{"stylingStrategy":"","dependencyPolicy":""}  <-- REJECTED: optional string fields must be non-empty when present; omit them instead',
-            "",
-            "### 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 - 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',
-        ].join("\n");
-    })();
     const frontendContractFieldSummary = [
         "## Contract field summary (authoritative JSON; no plan prose)",
-        "The plan/revision node emits only a fenced json contract — 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",
-        "- targets: files, routes, publicApiChanges",
+        "- targets: routes, publicApiChanges (files are runtime-owned)",
         "- mockApi: strategy, productionDefaultOff, activation, endpoints[]",
         "- verificationTargets[]: id, type, commandLabel, file, symbol, requirementIds, uiStates",
-        "- designEvidence: source, paths, conflicts; evidenceGaps[]",
-        "- optional: implementationSteps[], stylingStrategy, uiComponentChoices[], dependencyPolicy, residualRisks[], realIntegrationGap",
+        "- 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",
         "Do not require or read a separate plan prose section; the contract JSON is the only plan surface.",
     ].join("\n");
-    const frontendPlanFieldGuide = [
-        "## Compact planner field guide",
-        "Emit only editable fields: requirements[], implementationSteps[], targets.routes/publicApiChanges, uiStates[], interactions[], mockApi.strategy/activation/endpoints, verificationTargets[], designEvidence, evidenceGaps[], stylingStrategy, uiComponentChoices[], dependencyPolicy, residualRisks[], realIntegrationGap.",
-        "Protected and forbidden: schemaVersion, sourceBinding, riskLevel, targets.files, mockApi.productionDefaultOff, schemaId, targetFiles, requirementCoverage.",
-        "Invariants: every requirement has expectedOutcome; every interaction has trigger + expectedBehavior; applicable uiStates have expectedBehavior + implementationTargets + verificationTargetIds; non-applicable uiStates have notApplicableReason; commandLabel is frozen; mockApi production default remains off.",
-        "Enums: mock strategy native|browser-intercept|request-adapter|not-needed; uiComponentChoices decision specified|reuse-existing|new. Omit optional empty strings and unchanged revision fields.",
-    ].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"),
+        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;
-    const requirementCoverageInstruction = requirementIds.length > 0
-        ? [
-            `## Requirement Coverage (per-AC echo with bad/good examples)`,
-            `For each requirement ID below, echo the ID verbatim and confirm: expectedOutcome (user-observable or logic-observable), implementation targets (files), and verification targets (commandLabel + file).`,
-            `Do not skip any ID. Use the bad/good patterns below as reference for each field.`,
-            ``,
-            `Bad example (empty expectedOutcome, empty targets -- REJECTED at contract materialization):`,
-            `- AC-001: expectedOutcome="" implementationTargets=[] verificationTargets=[]`,
-            ``,
-            `Good example (concrete expectedOutcome, real files, real verification targets):`,
-            `- AC-001: expectedOutcome="TypeScript compilation exits with code 0 and produces no errors in dist/" implementationTargets=["src/app.tsx"] verificationTargets=["vt-typecheck":"npm run typecheck","tsconfig.json"]`,
-            ``,
-            ...requirementIds.map((id) => `- ${id}: [expectedOutcome] [implementation files] [verification targets]`),
-            ``,
-            `Every requirement MUST have a non-empty expectedOutcome. Every interaction MUST have non-empty trigger and expectedBehavior. UI states with applicable=true MUST have non-empty expectedBehavior. Empty strings or omitted fields for these will cause contract rejection.`,
-        ].join("\n")
-        : "";
-    const verificationTargetFileInstruction = [
-        `## Verification target file semantics`,
-        `verificationTargets[].file is the code file that the target verifies (the file the writer changes), NOT where the command is defined.`,
-        `Non-static targets (type unit/component/integration/mock) MUST set file to a concrete code file inside the implementation writeSet (task allowedPaths); the prewrite gate rejects any non-static target whose file falls outside the writeSet.`,
-        `Command-level checks that run project-wide (all tests, typecheck, build, governance) MUST use type "static" and must NOT be bound as non-static targets with file=package.json/tsconfig.json/vite.config.ts/scripts/*. Static targets are exempt from the writeSet containment check.`,
-    ].join("\n");
-    const mandatorySourceReadInstruction = [
-        "## Mandatory full source read before contracting",
-        "Before producing this contract/plan, use the Pi read tool to read the FULL bound source files (需求.md, 执行约束.md, and every `references/*` Bound readPath listed above) — the inline copies above may be truncated excerpts, and requirement/acceptance references are authoritative only in their full form.",
-        "Do not drop scope fields, acceptance criteria, non-goals, UI states, or column/field definitions that exist in the full sources but are absent from the inline excerpts; if a field appears in the full source, it belongs in the contract.",
-    ].join("\n");
     const strategy = resolveDagVerifyStrategy(taskConfig);
     const readOnlyPaths = taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"];
     const behaviorPaths = deriveFrontendBehaviorPaths(taskConfig);
@@ -2571,15 +2867,15 @@ async function buildFrontendHybridDagFromTask(sources) {
             ? [`See 执行约束.md in task source (${sources.taskId})`]
             : []),
         ...STANDARD_GLOBAL_CONSTRAINTS,
-        "Frontend implementation DAGs must pass the effective final design verdict gate before any write node executes; an initial pass uses the original plan, while request-revision selects the read-only revision and final-review branch.",
-        "Final design gate pass is the only authorization for frontend implementation writes.",
-        "Plan revision remains read-only and never edits business code.",
-        "Design revision failures route to replan-and-rerun, never dev-fix.",
+        "Frontend design policy (frontend-design-policy-shell) and writer admission (frontend-writer-admission-shell) are the only write authorization; the writer runs only after both materialized the canonical contract and admitted a concrete writeSet.",
+        "Design review verdict is consumed only as admission data input; it never drives branch selection.",
+        "Verification failure is terminal for the run: frontend-verify-shell fails closed, routes to recovery, and never selects a same-run repair branch.",
+        "Frontend review is decided exclusively by the committed typed terminal tools (approve_review / request_review_changes); response-text JSON verdicts and first-line VERDICT markers carry no control-flow weight.",
         "Frontend planning must consume the read-only Mock assessment strategy produced after scouting; MOCK_STRATEGY: blocked must not pass the deterministic Mock contract gate.",
         "Mock implementations must preserve the real request path as the default, require explicit test/dev activation, and never rely on commenting out the real request.",
         "Mock-backed behavior evidence proves only the documented frontend contract, never real API integration.",
         "frontend-implementation DAGs must complete deterministic static verification before final review. Behavior verification is also required when the task declares a behavior entrypoint or the implementation contract contains a non-static verification target; static-only contracts must map every target to the declared static entrypoint.",
-        "frontend review must block closeout unless review verdict is exactly VERDICT: pass.",
+        "Frontend closeout renders only from committed facts; a weak status (failed / not-run / baseline-debt / mock-backed / pending) can never be rewritten into a stronger one (passed / real-integrated).",
         `Frontend risk classification: ${frontendRisk.selectedRisk} — ${frontendRisk.reason}`,
         frontendRisk.forceFullGates
             ? "High-risk or supervised: keep full design gates; do not weaken write boundaries."
@@ -2595,7 +2891,14 @@ async function buildFrontendHybridDagFromTask(sources) {
         return buildBlockedFrontendMockDag(frontendSources, readOnlyPaths, forbiddenPaths, globalConstraints, blockedReason);
     }
     const fallbackVerifyCommands = await discoverFrontendFallbackVerifyCommands(sources.repoRoot);
-    const staticFallbackCommands = fallbackVerifyCommands.staticCommands;
+    // The verification bundle schema requires at least one static command. When
+    // a real project exposes no usable verification command at all, run an
+    // explicit no-op marker instead of a command that is guaranteed to fail:
+    // the trace then records not-run honestly and the advisory asks the task
+    // to declare verification commands and regenerate.
+    const staticFallbackCommands = fallbackVerifyCommands.staticCommands.length > 0
+        ? fallbackVerifyCommands.staticCommands
+        : [FRONTEND_NO_STATIC_VERIFICATION_MARKER];
     const behaviorFallbackCommands = fallbackVerifyCommands.behaviorCommands;
     const parsedFrontendVerifyCommands = extractFrontendVerifyCommandsFromMarkdown({
         repoRoot: sources.repoRoot,
@@ -2694,11 +2997,65 @@ async function buildFrontendHybridDagFromTask(sources) {
         ...behaviorVerifyEvidence.commandLabels.map((command) => `  - ${JSON.stringify(command)}`),
     ].join("\n");
     const advisories = [];
+    if (!hasDeclaredFrontendVerification &&
+        fallbackVerifyCommands.staticCommands.length === 0 &&
+        fallbackVerifyCommands.behaviorCommands.length === 0) {
+        advisories.push("未发现可用的前端验证命令：目标项目没有可读取的 package.json scripts，也未探测到本地 TypeScript，verify 节点将没有静态/行为命令可执行。请在 task.json --verify 或执行约束.md 的验证约束中显式声明命令（例如 node --check src/app.js），然后重新生成 DAG。");
+    }
     if (frontendSourceMentionsMock(frontendSources) &&
         frontendMockStrategyMustBeNotNeeded(frontendSources)) {
         advisories.push("auto 模式已将 Mock 策略收窄为 not-needed：任务源提到接口/API/Mock 需求，但仓库无确认 Mock 能力或无确定性 Mock 验证命令。若项目规范要求 Mock，请声明 frontendMock.verifyCommands 或 policy:required 后重新生成 DAG。");
     }
-    const openspecGate = resolveFrontendOpenspecGateConfig(sources);
+    const openspecGate = await resolveFrontendOpenspecGateConfig(sources);
+    const requiresOpenspecClassification = openspecGate.openspecPolicy === "cited" &&
+        openspecGate.openspecCandidatePaths.length > 0;
+    // Prompt 内联的候选只保留与任务相关的子集：mandatory（任务显式声明/
+    // 引用）始终保留；scan-strict 候选按路径段是否命中任务源关键词过滤。
+    // runtime 的选型/read 门禁仍消费完整 openspecCandidatePaths——这里只
+    // 减小 prompt 体积，不改变门禁语义；未提及的候选 runtime 默认 irrelevant。
+    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,
+        schemaId: "frontend-openspec-selection-v1",
+        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
@@ -2715,7 +3072,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             advisories.push("openspec 策略 cited：契约声明的 requiredReadPaths 与任务源引用均为空，prewrite gate 不强制读取 openspec；如需增强规范门禁，请在 task.json.frontendOpenspec.requiredReadPaths 声明必读路径或在任务源中显式引用 openspec 文件。");
         }
         else {
-            advisories.push(`openspec 策略 cited：候选 ${openspecGate.openspecCandidatePaths.length} 个（declared ${openspecGate.openspecCandidateSources.declared.length} / task-source-cited ${openspecGate.openspecCandidateSources.taskSourceCited.length}），plan/review 必须在 openspec-citations 引用块中逐条引用并真实读取。`);
+            advisories.push(`openspec 策略 cited：候选 ${openspecGate.openspecCandidatePaths.length} 个（declared ${openspecGate.openspecCandidateSources.declared.length} / task-source-cited ${openspecGate.openspecCandidateSources.taskSourceCited.length}），plan 必须在 typed decision ledger 的 uiComponentChoices.specReference 中声明并通过真实 read 事件佐证。`);
         }
     }
     else {
@@ -2753,13 +3110,23 @@ async function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown contract with Scope, Non-goals, Acceptance Criteria, UI States, Target Runtime Environment, Risks, and Verification Expectations. No file writes.",
+                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.",
-                    "Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations.",
+                    "Read task source and produce a concise frontend implementation contract as typed requirement facts plus narrative Markdown.",
+                    "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.",
-                    mandatorySourceReadInstruction,
-                    sourceContext,
+                    sourceContexts.contract,
                 ].join("\n\n"),
             },
             {
@@ -2769,17 +3136,19 @@ async function buildFrontendHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: mapTaskComplexity(taskConfig.complexity),
                 writePolicy: "read-only",
+                retryPolicy: FRONTEND_SCOUT_COMPLETENESS_RETRY_POLICY,
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown scout report with a required TARGET_SURFACE section covering frontend stack, routes, components, styling system, existing design conventions, state/data flow, test entry points, reuse opportunities, and risks. No file writes.",
+                outputContract: "Markdown scout report covering target surface and design evidence (frontend stack, routes, components, styling system, existing design conventions, state/data flow, test entry points, reuse opportunities, risks). Submit through the incremental evidence tools record_target_surface / record_design_evidence. A complete target surface is mandatory before Plan; if it cannot be proven, commit blocked with unresolved paths so this Scout node retries rather than shifting discovery to Plan. No fixed TARGET_SURFACE section title is required — target surface and design evidence are reported as committed typed facts. No file writes.",
                 subtask_prompt: [
                     "Inspect frontend code, routing, components, styles, package scripts, and tests.",
                     "Return code and design observations, existing reuse opportunities, and verification entry points.",
-                    "Begin with a TARGET_SURFACE section containing exactly these labels: 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.",
+                    "Report target surface and design evidence as facts (no fixed section title required): completeness, entrypoint, routeOrMount, implementationPaths, testPaths, dataSource, allowedPathConflicts, unresolvedPaths. Use repository-relative POSIX paths. A complete surface must name at least one proven entrypoint, implementation path, or test path and set unresolvedPaths to []; if any target ownership remains unknown, commit completeness=blocked with every unresolved path instead of guessing. 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"),
             },
             {
@@ -2789,246 +3158,200 @@ async function buildFrontendHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: "MED",
                 writePolicy: "read-only",
-                outputMode: "structured-required",
-                retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
+                retryPolicy: FRONTEND_PLAN_LADDER_RETRY_POLICY,
+                readBudget: {
+                    maxFiles: 40,
+                    maxBytes: 512 * 1024,
+                    maxOperations: 40,
+                    onExhaustion: "return-guidance",
+                },
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                skills: FRONTEND_IMPLEMENTATION_SKILLS,
                 structuredContractOutput: {
-                    schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_PLAN_PATCH_SCHEMA_ID,
+                    schemaId: "frontend-implementation-contract-plan-patch-v1",
                     retryOnInvalid: true,
                     skeleton: frontendContractSkeleton,
                 },
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                skills: [],
-                outputContract: "JSON-only patch output: one-line lead-in, then exactly ONE fenced json object (```json ... ```) containing only the editable RFC 7386 plan patch for the runtime contract skeleton. Omit protected fields: schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. Immediately after it, append exactly one ```openspec-citations``` fenced citation block. The runtime applies the patch, validates it, and promotes canonical full-contract JSON for downstream review. Do NOT emit a full contract, Markdown plan explanation, raw JSON, or any other fenced block. No file writes.",
+                outputContract: "Typed decision patch only: map frozen requirements to implementation/verification targets and select the needed component, state, data/Mock, styling, and dependency decisions. Use only the record_* tools needed to express those decisions, then call finalize_plan exactly once. Contract owns requirement semantics; Scout owns repository discovery; deterministic runtime owns schema, protected fields, path containment, and command validation. No Markdown narrative or file writes.",
                 subtask_prompt: [
-                    "Use frontend-contract-pi, frontend-scout-pi, task sources, and the generation-time Mock capability evidence to fill the runtime-owned frontend contract skeleton. Return JSON-only output containing only an editable RFC 7386 plan patch. The runtime already owns schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff; omit those protected paths even when their values look obvious.",
-                    "The patch fields become the complete implementation plan after deterministic merge. Do not produce a separate plan document, prose mirror, or full contract.",
-                    "Select the Mock / API strategy only in the patch. Encode endpoint/fixture mapping, explicit activation, verification commands, and Real Integration Gap in schema-defined editable fields; productionDefaultOff comes from the protected skeleton and there is no second plan output.",
-                    "Encode ordered steps (implementationSteps), target files, UI state handling, styling/component strategy (stylingStrategy), interaction notes, Mock/API strategy, dependency policy (dependencyPolicy), deterministic verification entrypoints, Real Integration Gap (realIntegrationGap), and residual risks (residualRisks) into the contract JSON fields. Use only the fixed entrypoints below; implementation may add tests behind them but cannot replace them.",
-                    "Every target file and verification target must be selected from the current target workspace and task scope. Do not reuse paths or symbols from examples, prior tasks, or loop-agent itself; if the project uses app/, packages/, spec/, __tests__, or another layout, preserve that layout.",
-                    "Consume the Scout TARGET_SURFACE evidence before selecting files. Preserve the discovered existing entrypoint and data source. If implementationPaths or testPaths are outside task allowedPaths, record a blocking scope conflict; do not substitute a new page or silently broaden the writeSet.",
-                    "Output in this exact order: (1) exactly one fenced json object containing the editable plan patch; (2) exactly one openspec-citations citation fenced block appended immediately after it. Do NOT emit protected skeleton fields, a full contract, Markdown plan explanation, raw JSON, or any other fenced block.",
-                    "Each requirement must state its user-observable or logic-observable expectedOutcome. Each interaction must state its trigger and expectedBehavior. IDs plus file paths are not sufficient behavior semantics.",
-                    requirementCoverageInstruction,
-                    "verificationTargets[].commandLabel MUST be one of the frozen command labels listed above. Any other value will be rejected at contract materialization.",
-                    verificationTargetFileInstruction,
-                    "Read-only: do not modify code, docs, artifacts, or repository files.",
-                    mandatorySourceReadInstruction,
+                    "Plan only the delta between the frozen frontend-contract-pi facts and frontend-scout-pi target surface. Do not reinterpret the task, repeat requirements, search the repository, or choose implementation order.",
+                    "Record only: requirement-to-file/verification coverage; component/styling choices; applicable UI state and interaction behavior; data/Mock strategy; and a dependency policy or genuine evidence gap. Reuse Scout paths. If scope is missing, record a blocking gap instead of inventing a path.",
+                    "Use the typed tool schemas as the field contract. Runtime owns schemaVersion, sourceBinding, riskLevel, targets.files, mockApi.productionDefaultOff, aliases, command allowlisting, path containment, and final validation; do not restate those rules or emit a full JSON contract.",
+                    `Cover each frozen requirement ID exactly once: ${requirementIds.join(", ") || "(none)"}. Bind every verification target to a listed frozen command and a Scout-confirmed file. Use static targets for project-wide commands.`,
+                    ...(requiresOpenspecClassification ? ["When a component choice uses an OpenSpec selection, cite that selection; otherwise do not classify unrelated candidates."] : []),
+                    "Call finalize_plan exactly once after the necessary typed facts. Return no Markdown narrative.",
+                    "READ BUDGET: use injected Contract/Scout facts. Do not search or re-read task sources. If an upstream preview is truncated, you may read only its explicitly listed artifact path. You may also read one or more Scout-confirmed target paths when a specific component/state/test decision needs direct evidence. grep/find/ls are unavailable; a non-Scout repository path is denied. After the read cap, stop and finalize from existing facts or record a genuine evidence gap.",
                     fixedVerificationContext,
-                    sourceContext,
+                    scopedOpenspecContext,
                     mockContextBlock,
-                    frontendPlanFieldGuide,
+                    frontendContractFieldSummary,
                     frontendComponentConformanceInstruction,
-                    openspecCitationInstruction,
                 ].join("\n\n"),
             },
             {
-                id: "frontend-design-review-pi",
+                id: "frontend-design-policy-shell",
                 depends_on: ["frontend-plan-pi"],
-                role: "reviewer",
-                executor: "pi",
-                complexity: "MED",
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
                 writePolicy: "read-only",
-                artifactFirstUpstreamNodeIds: ["frontend-plan-pi"],
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                skills: FRONTEND_DESIGN_REVIEW_SKILLS,
-                outputProtocol: REVIEW_VERDICT_OUTPUT_PROTOCOL,
-                outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by Findings, Required Plan Corrections, and Checked Items. No file writes.",
-                subtask_prompt: [
-                    "Audit the frontend plan before implementation. frontend-plan-pi is emitted to you as canonical full-contract JSON after the runtime applied and validated the planner's editable patch against its protected skeleton; there is no separate plan prose.",
-                    "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "Request revision 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 revision 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: VERDICT: request-revision 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 not cited in the openspec-citations block or has no successful read event.",
-                    "Read-only: do not modify repository files.",
-                    fixedVerificationContext,
-                    sourceContext,
-                    frontendContractFieldSummary,
-                    mockContextBlock,
-                ].join("\n\n"),
-            },
-            {
-                id: "frontend-plan-revision-pi",
-                depends_on: ["frontend-plan-pi", "frontend-design-review-pi"],
-                runIf: "$.nodes['frontend-design-review-pi'].firstVerdictLine == 'VERDICT: request-revision'",
-                role: "planner",
-                executor: "pi",
-                complexity: "MED",
-                writePolicy: "read-only",
-                artifactFirstUpstreamNodeIds: ["frontend-plan-pi"],
-                outputMode: "structured-required",
-                retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
-                structuredContractOutput: {
-                    schemaId: "frontend-implementation-contract-revision-patch-v1",
-                    retryOnInvalid: true,
+                outputContract: "Deterministic design policy: materialize the canonical frontend implementation contract from the plan patch, enforce requirement-id retention, Mock strategy/frozen-command binding, writeSet containment, source freshness, and openspec invariants, then evaluate the design policy (write policy result).",
+                subtask_prompt: "Materialize the canonical contract and fail closed unless the deterministic design policy approves. The design verdict is not available at this stage; the writer admission shell enforces it.",
+                shell: {
+                    commands: [],
+                    frontendDesignPolicy: {
+                        schemaVersion: 1,
+                        planFromNodeId: "frontend-plan-pi",
+                        requiredRequirementIds: requirementIds,
+                        allowedMockStrategies: taskConfig.frontendMock?.policy === "disabled" ||
+                            frontendMockStrategyMustBeNotNeeded(frontendSources)
+                            ? ["not-needed"]
+                            : taskConfig.frontendMock?.policy === "required"
+                                ? [
+                                    "native",
+                                    "browser-intercept",
+                                    "request-adapter",
+                                ]
+                                : [
+                                    "native",
+                                    "browser-intercept",
+                                    "request-adapter",
+                                    "not-needed",
+                                ],
+                        mockCommandLabels: mockVerifyEvidence?.commandLabels ?? [],
+                        artifactName: "frontend-implementation-contract.json",
+                        outputDir: "contracts",
+                        requireSourceFreshness: true,
+                        implementationWriteSet: implementPaths.writeSet,
+                        openspecPolicy: openspecGate.openspecPolicy,
+                        openspecSpecRoots: taskConfig.frontendOpenspec?.specRoots ?? [
+                            ...DEFAULT_FRONTEND_SPEC_ROOTS,
+                        ],
+                        ...(requiresOpenspecClassification
+                            ? { openspecSelectionNodeId: "frontend-contract-pi" }
+                            : {}),
+                        openspecMandatoryPaths: openspecGate.openspecMandatoryPaths,
+                        openspecCandidateSources: {
+                            declared: openspecGate.openspecCandidateSources.declared,
+                            taskSourceCited: openspecGate.openspecCandidateSources.taskSourceCited,
+                            scanStrict: openspecGate.openspecCandidateSources.scanStrict,
+                        },
+                        openspecCandidatePaths: openspecGate.openspecCandidatePaths,
+                        ...(openspecGate.openspecCandidateSnapshots
+                            ? {
+                                openspecCandidateSnapshots: openspecGate.openspecCandidateSnapshots,
+                            }
+                            : {}),
+                        componentSpecCandidatePaths,
+                        allowedDependencies: declaredDependencies,
+                    },
+                    cwd: ".",
+                    timeoutMs: 60000,
                 },
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                skills: [],
-                outputContract: "When the initial design review requests revision, return a one-line lead-in followed by exactly ONE fenced json object (```json ... ```) containing an RFC 7386 merge-patch delta against the original frontend-implementation-contract-v1 (only the fields you change; null deletes a key; arrays and scalars replace; plain objects merge recursively). Immediately after it, append exactly one ```openspec-citations``` fenced citation block. Do NOT emit a full contract, Markdown explanation, or prose — the output is JSON-only; the gate applies the patch on the original contract and renders plan.md deterministically. Apart from the patch JSON fenced block and the openspec-citations block, do not emit any other fenced block or raw JSON. No file writes.",
-                subtask_prompt: [
-                    "Consume frontend-plan-pi (original contract JSON) and frontend-design-review-pi (first design review findings).",
-                    "This node runs only when frontend-design-review-pi emitted VERDICT: request-revision. Produce an RFC 7386 merge-patch delta against the original contract JSON that addresses every Required Plan Correction from the design findings.",
-                    "The patch delta may update editable contract fields such as requirements, implementationSteps, targets.routes/publicApiChanges, uiStates, interactions, mockApi.strategy/activation/endpoints, dependencyPolicy, stylingStrategy, uiComponentChoices, verificationTargets, evidenceGaps, residualRisks, and realIntegrationGap. It must not modify protected schemaVersion, sourceBinding, riskLevel, targets.files, or mockApi.productionDefaultOff. Only include fields you change; omit unchanged fields (the gate applies the patch on the original contract). null deletes a key; arrays and scalars replace; plain objects merge recursively.",
-                    requirementCoverageInstruction,
-                    "Do not turn MOCK_STRATEGY: blocked into an implementable strategy without new repository or contract evidence that resolves every blocker.",
-                    "Read-only: do not modify code, docs, artifacts, or repository files. This node revises the plan only.",
-                    "Output in this exact order: (1) exactly one fenced json object containing the merge-patch delta — this is the only plan output the prewrite gate applies on the original contract; (2) exactly one openspec-citations citation fenced block appended immediately after it. Do NOT emit a full contract, Markdown explanation, or prose — the output is JSON-only. Do not emit any raw JSON or JSON objects in prose. Apart from the patch JSON fenced block and the openspec-citations block, do not emit any other fenced block. Do not include secrets or unsafe paths.",
-                    "Preserve each requirement expectedOutcome and each interaction trigger/expectedBehavior in the effective (merged) contract; do not reduce behavior semantics to IDs and paths.",
-                    "verificationTargets[].commandLabel MUST be one of the frozen command labels listed above. Any other value will be rejected at contract materialization.",
-                    verificationTargetFileInstruction,
-                    fixedVerificationContext,
-                    sourceContext,
-                    frontendPlanFieldGuide,
-                    mockContextBlock,
-                    frontendComponentConformanceInstruction,
-                    openspecCitationInstruction,
-                ].join("\n\n"),
             },
             {
-                id: "frontend-final-design-review-pi",
-                depends_on: [
-                    "frontend-plan-revision-pi",
-                    "frontend-plan-pi",
-                    "frontend-design-review-pi",
-                ],
-                dependsPolicy: "all-or-condition-skip",
-                runIf: "$.nodes['frontend-design-review-pi'].firstVerdictLine == 'VERDICT: request-revision'",
+                id: "frontend-design-review-pi",
+                depends_on: ["frontend-design-policy-shell"],
                 role: "reviewer",
                 executor: "pi",
                 complexity: "MED",
                 writePolicy: "read-only",
-                artifactFirstUpstreamNodeIds: [
-                    "frontend-plan-revision-pi",
-                    "frontend-plan-pi",
-                ],
+                readBudget: FRONTEND_READ_BUDGETS.designReview,
+                retryPolicy: DEFAULT_READ_ONLY_PI_RETRY_POLICY,
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_DESIGN_REVIEW_SKILLS,
-                outputProtocol: REVIEW_VERDICT_OUTPUT_PROTOCOL,
-                outputContract: "For the effective frontend plan, return plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by Findings and Checked Items. No file writes.",
+                outputContract: "Authoritative typed design terminal via approve_design / request_design_changes tools. No JSON verdict; the committed typed design fact is the only authority. No file writes.",
                 subtask_prompt: [
-                    "Audit the revised frontend plan before implementation. This node runs only after request-revision and consumes the merge-patch delta from frontend-plan-revision-pi applied on the original frontend-plan-pi contract JSON — there is no separate plan prose.",
-                    "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "Verify that every Required Plan Correction from the initial design review has been fully addressed.",
-                    "Recheck the selected Mock / API strategy, contract-to-fixture mapping, authorized paths/dependencies, explicit activation, production-default-off behavior, behavior verification, and Real Integration Gap. MOCK_STRATEGY: blocked cannot receive VERDICT: pass.",
-                    "Review every explicit REQ-/BR-/AC- mapping; the downstream prewrite gate also checks identifier retention deterministically.",
-                    "Request revision if any design gap remains, if corrections are incomplete, or if the revised plan introduces new unaddressed issues.",
-                    "Also request revision for component selection non-conformance: spec-defined components silently replaced or self-invented without a declared deviation, uiComponentChoices missing for UI-visible work, or a uiComponentChoices specReference.path not cited in the openspec-citations block / not actually read.",
+                    "Audit the frontend plan before implementation. frontend-plan-pi is emitted to you as canonical full-contract JSON after the runtime applied and validated the planner's editable patch against its protected skeleton; there is no separate plan prose.",
+                    "Your authoritative terminal verdict is exactly one committed typed tool call: approve_design or request_design_changes. Call exactly one of them; after calling one, do not call the other.",
+                    "request_design_changes must carry a typed issueCategory, at least one evidenceRef, and non-empty findings.",
+                    "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; 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.",
+                    "LARGE-FILE AUDIT (avoid full reads): style/theme audit files can be large (e.g. styles.css is often hundreds of KB). Prefer grep to locate the exact rules/variables you must verify (e.g. grep the oc- class, is-* modifier, or --oc- theme variables with their line numbers), then read only the narrow line range when surrounding context is needed. Do not read a large style/test file in full — a single full read can exhaust the read budget and fail the attempt.",
+                    "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"),
             },
             {
-                id: "frontend-prewrite-gate-shell",
-                depends_on: [
-                    "frontend-final-design-review-pi",
-                    "frontend-design-review-pi",
-                    "frontend-plan-revision-pi",
-                    "frontend-plan-pi",
-                ],
-                dependsPolicy: "all-or-condition-skip",
+                id: "frontend-writer-admission-shell",
+                depends_on: ["frontend-design-policy-shell", "frontend-design-review-pi"],
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Deterministic prewrite authorization: resolve effective plan/review, require VERDICT: pass, retain every requirement id, validate Mock policy, and materialize the canonical implementation contract.",
-                subtask_prompt: "Fail closed unless the effective reviewed plan is source-bound, requirement-complete, Mock-policy compliant, schema-valid, and approved.",
+                outputContract: "Deterministic writer admission: require design review verdict pass, freeze the pre-writer worktree/lint baselines, derive the concrete writeSet + admission digest, and write contracts/frontend-writer-admission-result.json (schemaId frontend-writer-admission-shell-v1).",
+                subtask_prompt: "Fail closed unless the design review approved and the deterministic admission derived a concrete, non-empty writeSet. The admission result is the only write authorization.",
                 shell: {
                     commands: [],
-                    frontendPrewriteGate: {
+                    frontendWriterAdmission: {
                         schemaVersion: 1,
-                        planFromNodeId: "frontend-plan-revision-pi",
-                        planFallbackFromNodeIds: ["frontend-plan-pi"],
-                        reviewFromNodeId: "frontend-final-design-review-pi",
-                        reviewFallbackFromNodeIds: ["frontend-design-review-pi"],
-                        requiredRequirementIds: requirementIds,
-                        mockCommandLabels: mockVerifyEvidence?.commandLabels ?? [],
+                        designReviewFromNodeId: "frontend-design-review-pi",
+                        frozenCommandLabels: [
+                            ...staticVerifyEvidence.commandLabels,
+                            ...behaviorVerifyEvidence.commandLabels,
+                            ...(mockVerifyEvidence?.commandLabels ?? []),
+                        ],
                         allowedMockStrategies: taskConfig.frontendMock?.policy === "disabled" ||
                             frontendMockStrategyMustBeNotNeeded(frontendSources)
                             ? ["not-needed"]
                             : taskConfig.frontendMock?.policy === "required"
-                                ? ["native", "browser-intercept", "request-adapter"]
+                                ? [
+                                    "native",
+                                    "browser-intercept",
+                                    "request-adapter",
+                                ]
                                 : [
                                     "native",
                                     "browser-intercept",
                                     "request-adapter",
                                     "not-needed",
                                 ],
-                        artifactName: "frontend-implementation-contract.json",
-                        outputDir: "contracts",
-                        revisionPatch: true,
-                        planMdArtifactName: "frontend-plan.md",
-                        requireSourceFreshness: true,
-                        implementationWriteSet: implementPaths.writeSet,
-                        openspecPolicy: openspecGate.openspecPolicy,
-                        openspecCandidateSources: {
-                            declared: openspecGate.openspecCandidateSources.declared,
-                            taskSourceCited: openspecGate.openspecCandidateSources.taskSourceCited,
-                            scanStrict: openspecGate.openspecCandidateSources.scanStrict,
-                        },
-                        openspecCandidatePaths: openspecGate.openspecCandidatePaths,
-                        componentSpecCandidatePaths,
+                        ...(lintShellCommands.length > 0 && lintVerifyEvidence
+                            ? {
+                                lintCommands: lintShellCommands,
+                                lintEvidence: lintVerifyEvidence,
+                            }
+                            : {}),
                     },
                     cwd: ".",
                     timeoutMs: 60000,
                 },
             },
-            ...(lintShellCommands.length > 0 && lintVerifyEvidence
-                ? [
-                    {
-                        id: "frontend-lint-baseline-shell",
-                        depends_on: ["frontend-prewrite-gate-shell"],
-                        role: "verifier",
-                        executor: "shell",
-                        complexity: "LOW",
-                        writePolicy: "read-only",
-                        allowedPaths: readOnlyPaths,
-                        forbiddenPaths,
-                        outputContract: "Capture writer-preceding lint output as frontend-lint-baseline-v1 without treating existing lint diagnostics as writer failure.",
-                        subtask_prompt: "Run the frozen lint commands read-only. Preserve raw output and mark the baseline unavailable on timeout, execution failure, unparseable output, or worktree mutation.",
-                        shell: {
-                            commands: lintShellCommands,
-                            frontendLintBaseline: {
-                                schemaVersion: 1,
-                                lintCommands: lintShellCommands,
-                                lintEvidence: lintVerifyEvidence,
-                            },
-                            cwd: ".",
-                            timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
-                        },
-                    },
-                ]
-                : []),
             {
                 id: implementId,
-                depends_on: [
-                    "frontend-prewrite-gate-shell",
-                    ...(lintShellCommands.length > 0
-                        ? ["frontend-lint-baseline-shell"]
-                        : []),
-                ],
+                depends_on: ["frontend-writer-admission-shell"],
                 ...buildFrontendWriterNodeDefaults({
                     complexity: resolveWriterComplexity(taskConfig),
                     writeSet: implementPaths.writeSet,
                     allowedPaths: implementPaths.allowedPaths,
                     forbiddenPaths,
+                    writerOutcomePolicyType: "frontend-facts-v1",
                 }),
-                outputContract: "First non-empty line must be exactly one of: IMPLEMENTATION_OUTCOME: changed; IMPLEMENTATION_OUTCOME: already-satisfied; IMPLEMENTATION_OUTCOME: blocked. Then a Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
+                outputContract: "The implementation status is derived by the executor from mechanical facts (write-tool events, run delta, write guard, requirement coverage, focused-check), not from any IMPLEMENTATION_OUTCOME first line. Deliver a Markdown summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
                 subtask_prompt: [
-                    "Implement against the validated run-owned Frontend Implementation Contract from frontend-prewrite-gate-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
+                    "Implement against the validated run-owned Frontend Implementation Contract materialized by frontend-design-policy-shell (path/schema/hash) and authorized by frontend-writer-admission-shell. Do not rebuild the contract from Markdown alone.",
                     "The canonical contract already contains the approved requirement, target-file, UI-state, verification, design, and Mock/API decisions. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, or design-review prose, and do not repeat broad repository research. Inspect only contract target files and directly related local code needed to implement them.",
                     "Execute in fixed stages and report each in the delivery summary: (1) Contract confirm, (2) Tests sync, (3) Component/UI state implementation, (4) API/Mock wiring per contract.mockApi, (5) Focused checks behind frozen entrypoints only, (6) Diff cleanup.",
                     "Map every requirement id, expectedOutcome, interaction trigger/expectedBehavior, and applicable UI state from the contract to concrete files. Do not invent shell verification commands; only frozen static/behavior entrypoints will run.",
-                    "Begin implementation after the contract and its target files are confirmed. Do not spend the turn collecting optional context. If the canonical contract lacks behavior needed to edit safely, return IMPLEMENTATION_OUTCOME: blocked instead of reopening broad discovery.",
+                    "Begin implementation after the contract and its target files are confirmed. Do not spend the turn collecting optional context. If the canonical contract lacks behavior needed to edit safely, stop and state the blocking reason in the summary instead of reopening broad discovery.",
+                    "Your implementation status is derived by the executor from mechanical facts (persisted write-tool events, run delta, write guard, requirement coverage, focused-check failures), never from any IMPLEMENTATION_OUTCOME first line. Do not emit an IMPLEMENTATION_OUTCOME first line.",
+                    "The node runs a bounded micro-loop: after each write attempt the executor re-runs frozen focused checks and records a per-round diff checkpoint; the write guard stays active every round. Only repair local issues attributable to the current diff (syntax/type/import/format/unit-assert/obvious omission). Never change requirements, design, writeSet, or verification strictness inside the loop.",
                     "Implement only the approved Mock strategy carried by the validated contract. Preserve the real request path as the default, require explicit test/dev activation, and never comment out or replace the real request with inline data.",
-                    "frontend-prewrite-gate-shell confirmed the effective plan/review, requirement coverage, Mock policy, and contract. Stay within writeSet and preserve unrelated files.",
+                    "frontend-design-policy-shell materialized and validated the canonical contract; frontend-writer-admission-shell authorized the writeSet. Stay within writeSet and preserve unrelated files.",
                     "For native, browser-intercept, or request-adapter, implement contract-aligned fixtures/states and a dev/test-only activation boundary in this same writer. For not-needed, do not add Mock files or a framework and state the positive reason.",
                     "Do not write root artifacts/** unless explicitly included in writeSet. Do not claim Browser/visual verification.",
                     "Edit existing files with the structured edit/write tools. NEVER rewrite Markdown (or any file with quoting/backticks/indentation-sensitive content) via bash sed/awk/echo redirection: escaping mistakes silently corrupt the file and self-repair loops burn the run.",
@@ -3043,7 +3366,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     .join("\n\n"),
             },
             {
-                id: "frontend-verify-assess-shell",
+                id: "frontend-verify-shell",
                 depends_on: [implementId],
                 role: "verifier",
                 executor: "shell",
@@ -3051,8 +3374,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Run frozen Mock/static/behavior commands, materialize verification trace and repair assessment, and fail closed for non-repairable failures.",
-                subtask_prompt: "Execute the frontend verification bundle. Preserve per-command evidence; eligible repairable failures select the bounded repair branch.",
+                outputContract: "Run frozen Mock/static/behavior commands and materialize the verification trace. Any failure is terminal: no same-run repair branch, failure ownership facts are materialized for recovery.",
+                subtask_prompt: "Execute the frontend verification bundle. Preserve per-command evidence; a failure fails this node (terminal) and routes to recovery.",
                 shell: {
                     commands: [],
                     frontendVerificationBundle: {
@@ -3066,7 +3389,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                         staticEvidence: staticVerifyEvidence,
                         behaviorEvidence: behaviorVerifyEvidence,
                         lintBaselineNodeId: lintShellCommands.length > 0
-                            ? "frontend-lint-baseline-shell"
+                            ? "frontend-writer-admission-shell"
                             : undefined,
                         writerNodeIds: lintShellCommands.length > 0 ? [implementId] : [],
                         mode: "initial",
@@ -3075,85 +3398,17 @@ async function buildFrontendHybridDagFromTask(sources) {
                     timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
                 },
             },
-            {
-                id: "frontend-repair-pi",
-                depends_on: ["frontend-verify-assess-shell", implementId],
-                runIf: "$.nodes['frontend-verify-assess-shell'].json.eligible == true",
-                ...buildFrontendWriterNodeDefaults({
-                    complexity: resolveWriterComplexity(taskConfig),
-                    writeSet: implementPaths.writeSet,
-                    allowedPaths: implementPaths.allowedPaths,
-                    forbiddenPaths,
-                }),
-                outputContract: "First non-empty line must be exactly one of: IMPLEMENTATION_OUTCOME: changed; IMPLEMENTATION_OUTCOME: already-satisfied; IMPLEMENTATION_OUTCOME: blocked. Then a repair summary for an eligible repairable assessment. Must not expand writeSet, re-interpret requirements, skip tests, or enable Mock by default.",
-                subtask_prompt: [
-                    "Read contracts/frontend-repair-assessment.json and the validated frontend implementation contract.",
-                    "This node runs only for eligible=true. Apply the smallest fix for the classified repairable failure inside the original implement writeSet only.",
-                    "The repair assessment and canonical implementation contract are complete inputs for this phase. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, or design-review prose, and do not repeat repository-wide discovery.",
-                    "Do not change lint/type/test config, do not add .skip/.only, do not comment out real requests, do not default-enable Mock, do not add dependencies.",
-                    "Do not re-plan requirements or expand allowed paths. Browser/visual remain not-run.",
-                    ...(implementPaths.docIndexCompanions.length > 0
-                        ? [
-                            `Doc index sync is MANDATORY: ${implementPaths.docIndexCompanions.join(", ")} are catalog index files for this writeSet. When your repair adds, renames, or removes any indexed file, update ${implementPaths.docIndexCompanions.join(" and ")} in the same run; verification runs check-doc-index and fails the run on a missing index entry.`,
-                        ]
-                        : []),
-                    writerDeliveryContract(taskConfig),
-                ]
-                    .filter((value) => Boolean(value))
-                    .join("\n\n"),
-            },
-            {
-                id: "frontend-reverify-shell",
-                depends_on: ["frontend-repair-pi"],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                outputContract: "Post-repair Mock/static/behavior re-verification plus refreshed canonical trace; any failure blocks review.",
-                subtask_prompt: "Re-run the frozen frontend verification bundle after bounded repair and fail on any command or trace failure.",
-                shell: {
-                    commands: [],
-                    frontendVerificationBundle: {
-                        schemaVersion: 1,
-                        mockCommands: mockShellCommands,
-                        lintCommands: lintShellCommands,
-                        staticCommands: staticShellCommands,
-                        behaviorCommands: behaviorShellCommands,
-                        mockEvidence: mockVerifyEvidence,
-                        lintEvidence: lintVerifyEvidence,
-                        staticEvidence: staticVerifyEvidence,
-                        behaviorEvidence: behaviorVerifyEvidence,
-                        lintBaselineNodeId: lintShellCommands.length > 0
-                            ? "frontend-lint-baseline-shell"
-                            : undefined,
-                        writerNodeIds: lintShellCommands.length > 0
-                            ? [implementId, "frontend-repair-pi"]
-                            : [],
-                        mode: "repair",
-                    },
-                    cwd: ".",
-                    timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
-                },
-            },
             {
                 id: "frontend-review-context-shell",
-                depends_on: [
-                    "frontend-reverify-shell",
-                    "frontend-repair-pi",
-                    "frontend-verify-assess-shell",
-                    implementId,
-                ],
-                dependsPolicy: "all-or-condition-skip",
+                depends_on: ["frontend-verify-shell", implementId],
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Canonical frontend review context containing validated contract, lint assessment when configured, effective verification trace, repair assessment, and actual worktree diff.",
-                subtask_prompt: "Capture the actual diff and bind it to the effective initial-or-post-repair verification evidence for final review.",
+                outputContract: "Canonical frontend review context containing validated contract, lint assessment when configured, effective verification trace, optional verify-failure facts, and actual worktree diff.",
+                subtask_prompt: "Capture the actual diff and bind it to the effective verification evidence for final review.",
                 shell: {
                     commands: [],
                     frontendReviewContext: { schemaVersion: 1, requireBaseline: true },
@@ -3168,79 +3423,70 @@ 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,
                 skills: FRONTEND_REVIEW_SKILLS,
-                outputContract: 'Structured JSON review verdict only: {"schemaVersion":1,"verdict":"pass|request-revision","findings":[...],"verificationAssessment":"...","uxAssessment":"...","residualRisks":[...]}. No file writes.',
-                outputProtocol: REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL,
+                outputContract: 'Authoritative typed review terminal via approve_review / request_review_changes tools. No JSON verdict is required in the response text; the typed terminal fact is the only authority. No file writes.',
                 subtask_prompt: [
                     "Review the frontend implementation and verification evidence.",
-                    "Return exactly one final JSON object in this response. Do not repeat it, do not emit a second revision, do not wrap it in Markdown, and do not include prose outside the JSON.",
-                    'Required fields: schemaVersion: 1; verdict: "pass" or "request-revision"; findings: array of objects with severity ("Critical" | "Important" | "Minor" | "Info"), optional file, optional positive integer line, issue, and optional requiredChange.',
-                    'verdict "request-revision" requires at least one finding. verdict "pass" is invalid if any finding severity is Critical or Important.',
-                    'Any Critical or Important finding must force verdict "request-revision".',
-                    "Read contracts/frontend-review-context.json from frontend-review-context-shell. It binds the validated implementation contract, frontend lint assessment when lint is configured, effective initial-or-post-repair verification trace, repair assessment, 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.",
+                    "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. 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 reviewed plan materialized by the prewrite gate. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, 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.",
+                    "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.",
                     "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case verify that the real request remains the default and the Real Integration Gap is preserved.",
-                    "Inspect the frontend-verify-assess-shell or selected frontend-reverify-shell evidence in the review context directly, including the production/default-real-path static check, and require Mock activation to be off for that check.",
+                    "Inspect the frontend-verify-shell evidence in the review context directly, including the production/default-real-path static check, and require Mock activation to be off for that check.",
                     "Distinguish Mock-backed evidence from real API integration evidence and preserve the Real Integration Gap when the backend was not exercised.",
                     "Review implementation quality, behavior/state coverage, verification evidence, and maintainability. Read-only: do not modify files.",
                 ].join("\n\n"),
             },
             {
-                id: "frontend-review-gate-shell",
-                depends_on: ["frontend-review-pi"],
-                role: "verifier",
+                id: "frontend-closeout-shell",
+                depends_on: ["frontend-review-context-shell", "frontend-review-pi"],
+                role: "closeout",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: 'Deterministic frontend review verdict gate: exit 0 only when frontend-review-pi emits JSON verdict "pass".',
-                subtask_prompt: 'Deterministic gate: block downstream closeout unless frontend-review-pi emitted JSON verdict "pass".',
+                outputContract: "Deterministic closeout rendered from committed facts only: coverage matrix, lint status, integration facts, typed review verdict, cumulative diff, browser/visual not-run, risks, and follow-up. No model summaries are re-interpreted.",
+                subtask_prompt: "Render the closeout deterministically from frontend-review-context.json, the verification trace, and the committed typed review terminal fact.",
                 shell: {
                     commands: [],
-                    verdictGate: {
-                        fromNodeId: "frontend-review-pi",
-                        accept: ["pass"],
-                        routingAccept: ["request-revision"],
-                        label: "frontend review",
-                        source: "json-review-verdict",
+                    frontendCloseout: {
+                        schemaVersion: 1,
+                        reviewFromNodeId: "frontend-review-pi",
                     },
                     cwd: ".",
                     timeoutMs: 60000,
                 },
             },
-            {
-                id: "frontend-closeout-pi",
-                depends_on: [
-                    "frontend-review-context-shell",
-                    "frontend-review-gate-shell",
-                ],
-                role: "closeout",
-                executor: "pi",
-                complexity: "MED",
-                writePolicy: "read-only",
-                allowedPaths: taskConfig.allowedPaths.length > 0
-                    ? [...taskConfig.allowedPaths, "docs/**"]
-                    : ["**", "docs/**"],
-                forbiddenPaths,
-                skills: FRONTEND_VERIFICATION_SKILLS,
-                outputContract: "Markdown closeout summary with Changes, Mock Decision / Strategy / Files / Verification / Production Boundary, Verification Evidence, Review Result, Frontend Status, Real Integration Status, Known Risks, and Follow-up. No file writes.",
-                subtask_prompt: [
-                    "Return a frontend closeout summary covering Mock decision/strategy/files/verification/production boundary, changes, verification evidence, review result, known risks, and follow-up.",
-                    "Use only the canonical frontend-review-context.json plus the final frontend review gate verdict. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, design-review, writer, repair, or verification prose, and do not perform new repository research during closeout.",
-                    "Include a coverage matrix for each requirement id, applicable UI state, and verification target/check with status passed|failed|not-run|blocked|unavailable. Report lint separately as passed|baseline-debt|failed|unavailable; baseline-debt is explicit debt, not passed. Always state Browser accessibility verification: not-run and Visual regression: not-run. Use contracts/frontend-review-context.json and the effective frontend-verify-assess-shell or frontend-reverify-shell facts; do not invent Browser evidence from component tests.",
-                    `When only Mock-backed evidence passed, state exactly Frontend status: mock-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task to create/run after backend readiness. This follow-up is not auto-created or auto-executed. Never describe Mock evidence as real API integration.`,
-                    `When Mock was skipped in auto mode and no real API evidence passed, state exactly Frontend status: locally-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task when backend readiness matters.`,
-                    "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
-                ].join("\n\n"),
-            },
         ],
     };
-    spec.tasks = pruneFrontendTasksForRisk(spec.tasks, frontendRisk);
+    if (frontendTaskShape.shape === "split-required") {
+        spec.tasks = pruneFrontendTasksForSplitRequired(spec.tasks);
+    }
+    else {
+        const reshapeRaisedTopology = frontendTaskShape.signals.includes("shape-transition-reshape");
+        if (!reshapeRaisedTopology) {
+            spec.tasks = pruneFrontendTasksForRisk(spec.tasks, frontendRisk);
+        }
+        if (frontendTaskShape.shape === "micro") {
+            spec.tasks = pruneFrontendTasksForMicro(spec.tasks);
+        }
+    }
+    spec.advisories = [
+        ...(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);
@@ -4301,6 +4547,7 @@ async function buildBackendTestGapFillDag(sources) {
         ],
     };
     spec.backendTestLayout = layout;
+    applyBackendTestWorkspaceControl(spec, taskConfig.backendTest?.workspaceControl ?? "git");
     if (sharedSetup) {
         spec.backendTestSharedSetup = { ...sharedSetup };
     }
@@ -4757,6 +5004,7 @@ async function buildBackendTestHybridDag(sources) {
     // against the resolved layout. The default layout is identity, so the
     // packaged template stays byte-identical with the historical contract.
     applyBackendTestLayoutToDagSpec(spec, layout);
+    applyBackendTestWorkspaceControl(spec, taskConfig.backendTest?.workspaceControl ?? "git");
     // Plan B: carry the bound shared-setup document on the spec so runtime
     // validators (N6 markdown case validation) see the same binding as prompts.
     if (intake.sharedSetup) {
@@ -4767,6 +5015,23 @@ async function buildBackendTestHybridDag(sources) {
     assertValidDagSpec(spec);
     return spec;
 }
+function applyBackendTestWorkspaceControl(spec, control) {
+    if (control !== "filesystem-only") {
+        delete spec.backendTestWorkspaceControl;
+        return;
+    }
+    spec.backendTestWorkspaceControl = control;
+    for (const task of spec.tasks) {
+        if ((task.executor === "pi" && task.toolProfile === "write") ||
+            task.shell?.backendTestPipeline) {
+            task.writeGuardPolicy = "filesystem-only";
+        }
+        const child = task.dynamicExpansion?.childTask;
+        if (child?.executor === "pi" && child.toolProfile === "write") {
+            child.writeGuardPolicy = "filesystem-only";
+        }
+    }
+}
 /** Rewrite layout-dependent strings across a compiled backend-test DAG spec (plan A). */
 function applyBackendTestLayoutToDagSpec(spec, layout) {
     if (layout.isDefault) {
@@ -4809,11 +5074,57 @@ function applyBackendTestLayoutToDagSpec(spec, layout) {
     spec.successCriteria = spec.successCriteria?.map(rewrite);
     spec.backendTestLayout = layout;
 }
+/** Rewrite layout-dependent strings across a compiled frontend-test DAG spec. */
+function applyFrontendTestLayoutToDagSpec(spec, layout) {
+    if (layout.isDefault) {
+        spec.frontendTestLayout = layout;
+        return;
+    }
+    const rewrite = (value) => applyFrontendTestLayoutToText(value, layout);
+    for (const task of spec.tasks) {
+        task.subtask_prompt = rewrite(task.subtask_prompt);
+        if (task.outputContract)
+            task.outputContract = rewrite(task.outputContract);
+        task.writeSet = task.writeSet?.map(rewrite);
+        task.allowedPaths = task.allowedPaths?.map(rewrite);
+        task.forbiddenPaths = task.forbiddenPaths?.map(rewrite);
+        if (task.dynamicExpansion?.childTask) {
+            const child = task.dynamicExpansion.childTask;
+            if (typeof child.subtaskPromptTemplate === "string") {
+                child.subtaskPromptTemplate = rewrite(child.subtaskPromptTemplate);
+            }
+            if (typeof child.outputContract === "string") {
+                child.outputContract = rewrite(child.outputContract);
+            }
+            if (Array.isArray(child.allowedPaths)) {
+                child.allowedPaths = child.allowedPaths.map((entry) => typeof entry === "string" ? rewrite(entry) : entry);
+            }
+            if (Array.isArray(child.writeSet)) {
+                child.writeSet = child.writeSet.map((entry) => typeof entry === "string" ? rewrite(entry) : entry);
+            }
+            if (Array.isArray(child.forbiddenPaths)) {
+                child.forbiddenPaths = child.forbiddenPaths.map((entry) => typeof entry === "string" ? rewrite(entry) : entry);
+            }
+        }
+        if (task.shell?.commands) {
+            task.shell.commands = task.shell.commands.map(rewrite);
+        }
+    }
+    spec.globalConstraints = spec.globalConstraints?.map(rewrite);
+    spec.successCriteria = spec.successCriteria?.map(rewrite);
+    spec.frontendTestLayout = layout;
+}
+function allowedPathsCoverFrontendTestRoot(allowedPaths, testRoot) {
+    const probe = `${testRoot}/_layout_probe_`;
+    return allowedPaths.some((pattern) => pathMatchesPattern(testRoot, pattern) ||
+        pathMatchesPattern(probe, pattern));
+}
 // ---------------------------------------------------------------------------
 // Frontend browser-test RAG DAG template
 // ---------------------------------------------------------------------------
 function buildFrontendTestHybridDag(sources) {
     const rawFrontendTest = sources.taskConfig.frontendTest;
+    const layout = resolveFrontendTestLayout(rawFrontendTest);
     const config = {
         // Default 32: common FE suites cover ~24 AC with multi-dimension cases; 20 caused map maxExpandedNodes failures.
         maxCasesPerBatch: rawFrontendTest?.maxCasesPerBatch ?? 32,
@@ -4835,28 +5146,32 @@ function buildFrontendTestHybridDag(sources) {
     };
     const declaredRequirementIds = buildDagSourceBinding(sources).requirementIds;
     const declaredAcIds = declaredRequirementIds.filter((id) => /^AC(?:-[A-Z0-9]+)+$/i.test(id));
+    // Optional project-local UI anchor ledger: only mention it in prompts when it
+    // exists so ledger-less projects keep generating without noise.
+    const hasUiAnchorsLedger = Boolean(sources.repoRoot &&
+        existsSync(path.join(sources.repoRoot, layout.ragDir, "ui-anchors.md")));
+    const uiAnchorsLedgerInstruction = hasUiAnchorsLedger
+        ? `Also read ${layout.ragDir}/ui-anchors.md (UI anchor ledger). Every passing find assertion in generated cases must quote a ledger row whose 状态 is 有效 for the matching page x state section; rows marked 不可断言/失效 must not be used as passing assertions. When an AC names a control absent from the ledger section for that state, emit a blocked case note (blockedReason unique-control-unavailable) instead of exploratory find steps, and follow ledger 备注 alternatives (split-node short literals) exactly.`
+        : "";
     const reviewMode = config.reviewMode;
     const blockingReview = reviewMode === "blocking";
     const strictOutcomeGate = config.strictOutcomeGate;
     const maxRerunAttempts = config.maxRerunAttempts;
     const enableRetrospect = config.reports?.retrospect === true;
     const enableL5Report = config.reports?.l5 !== false;
-    const hasFrontendTestWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "testcase/frontend/**" ||
-        pattern === "testcase/**" ||
-        pattern === "**");
-    if (!hasFrontendTestWriteScope) {
-        throw new Error('frontend-test requires task.json allowedPaths to include "testcase/frontend/**" (or an explicit containing glob).');
+    if (!allowedPathsCoverFrontendTestRoot(sources.taskConfig.allowedPaths, layout.testRoot)) {
+        throw new Error(`frontend-test requires task.json allowedPaths to cover "${layout.testRoot}/**" (or an explicit containing glob).`);
     }
     const forbidden = commonForbiddenPaths(sources);
-    const ragWriteSet = ["testcase/frontend/rag/**"];
+    const ragWriteSet = [`${layout.ragDir}/**`];
     const caseDraftWriteSet = [
-        "testcase/frontend/cases/FE-*.md",
-        "testcase/frontend/cases/index.md",
-        "testcase/frontend/cases/manifest.draft.json",
+        `${layout.casesDir}/FE-*.md`,
+        `${layout.casesDir}/index.md`,
+        `${layout.casesDir}/manifest.draft.json`,
     ];
     // The shell materializer alone owns the final manifest boundary.
-    const casesWriteSet = ["testcase/frontend/cases/**"];
-    const evidenceRoot = "testcase/frontend/evidence";
+    const casesWriteSet = [`${layout.casesDir}/**`];
+    const evidenceRoot = layout.evidenceDir;
     const declaredAcIdsLiteral = JSON.stringify(declaredAcIds);
     const maxCasesPerBatchLiteral = String(config.maxCasesPerBatch);
     const checklistScript = [
@@ -4875,6 +5190,8 @@ function buildFrontendTestHybridDag(sources) {
         "const caseIdRe=/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/;",
         ,
         "const acIdRe=/^AC(?:-[A-Z0-9]+)+$/i;",
+        "const truncatedAcRe=/^AC-FE-[A-Z]+$/i;",
+        "const truncatedUndeclaredAcRe=/^(?:AC-\\d{3}|AC-FE-[A-Z]+)$/i;",
         "for(const c of manifest.cases){",
         " const id=c&&c.caseId||'?';",
         " if(typeof c.caseId!=='string'||!caseIdRe.test(c.caseId))issues.push({ruleId:'case-id-shape',caseId:id,detail:'caseId must be FE-<FEATURE>-<NNN>-<dimension>, never AC-FE-*'});",
@@ -4893,6 +5210,7 @@ function buildFrontendTestHybridDag(sources) {
         "   if(typeof ac!=='string'){issues.push({ruleId:'ac-id-shape',caseId:id,detail:String(ac)+' must look like AC-FE-001'});continue;}",
         "   if(/^FE-/i.test(ac)){issues.push({ruleId:'ac-id-is-case',caseId:id,detail:ac+' looks like caseId; acIds must be AC-*'});continue;}",
         "   if(!acIdRe.test(ac)){issues.push({ruleId:'ac-id-shape',caseId:id,detail:ac+' must look like AC-FE-001'});continue;}",
+        "   if(truncatedAcRe.test(ac)||(declaredAc.size===0&&truncatedUndeclaredAcRe.test(ac))){issues.push({ruleId:'ac-id-truncated',caseId:id,detail:ac+' is a truncated acceptance id (missing feature prefix or sequence number)'});continue;}",
         "   if(declaredAc.size>0&&!declaredAc.has(ac))issues.push({ruleId:'unknown-ac',caseId:id,detail:ac+' not in task sourceBinding.requirementIds'});",
         "  }",
         " }",
@@ -4924,6 +5242,8 @@ function buildFrontendTestHybridDag(sources) {
             `const declaredAc=new Set(${declaredAcIdsLiteral});`,
             "const seen=new Set(); const seenCasePath=new Set(); const seenEvidenceDir=new Set();",
             "const acIdRe=/^AC(?:-[A-Z0-9]+)+$/i;",
+            "const truncatedAcRe=/^AC-FE-[A-Z]+$/i;",
+            "const truncatedUndeclaredAcRe=/^(?:AC-\\d{3}|AC-FE-[A-Z]+)$/i;",
             "for(const c of manifest.cases){",
             " if(!c||typeof c.caseId!=='string'||!/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/.test(c.caseId)) fail('case-id-shape','caseId must be FE-*, never AC-FE-*: '+String(c&&c.caseId));",
             " if(/^AC-/i.test(c.caseId)) fail('case-id-is-ac','caseId must not be an acceptance id: '+c.caseId);",
@@ -4931,7 +5251,7 @@ function buildFrontendTestHybridDag(sources) {
             " seen.add(c.caseId);",
             " if(typeof c.dimension!=='string'||!dims.has(c.dimension)) fail('invalid-dimension',String(c.dimension));",
             " if(!Array.isArray(c.acIds)||c.acIds.length===0||c.acIds.some(a=>typeof a!=='string'||!a.trim())) fail('ac-mapping','invalid acIds for '+c.caseId);",
-            " for(const ac of c.acIds){ if(!acIdRe.test(ac)) fail('ac-id-shape','acIds entry must be AC-* acceptance id, not caseId: '+ac); if(declaredAc.size>0&&!declaredAc.has(ac)) fail('unknown-ac',ac+' not in sourceBinding; repair generator input or AC list'); }",
+            " for(const ac of c.acIds){ if(!acIdRe.test(ac)) fail('ac-id-shape','acIds entry must be AC-* acceptance id, not caseId: '+ac); if(truncatedAcRe.test(ac)||(declaredAc.size===0&&truncatedUndeclaredAcRe.test(ac))) fail('ac-id-truncated','acIds entry is a truncated acceptance id (missing feature prefix or sequence number): '+ac); if(declaredAc.size>0&&!declaredAc.has(ac)) fail('unknown-ac',ac+' not in sourceBinding; repair generator input or AC list'); }",
             " c.casePath='testcase/frontend/cases/'+c.caseId+'.md';",
             " c.evidenceDir='testcase/frontend/evidence/'+c.caseId+'/';",
             " for(const k of ['casePath','evidenceDir']){ const v=c[k]; if(typeof v!=='string'||path.isAbsolute(v)||v.includes('..')) fail('unsafe-path',k+': '+String(v)); }",
@@ -4991,15 +5311,11 @@ function buildFrontendTestHybridDag(sources) {
             writeSet: ragWriteSet,
             allowedPaths: [...ragWriteSet],
             forbiddenPaths: forbidden,
-            outputContract: "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage.",
-            subtask_prompt: "Prepare frontend-test package: materialize standard-scenarios.v1.json into the RAG package.",
+            outputContract: "Write testcase/frontend/rag/standard-scenarios.v1.json for generate-time standard scenario coverage. Copy docs/templates or harness.json governanceRoot templates (including ai_workspace/loop-agent/templates) when present; otherwise write the minimal STD-FE-SMOKE-ENTRY fallback.",
+            subtask_prompt: "Prepare frontend-test package: materialize standard-scenarios.v1.json into the RAG package from docs/templates, governanceRoot/templates, or the init-projected ai_workspace/loop-agent/templates path.",
             shell: {
-                commands: [
-                    [
-                        "node -e",
-                        JSON.stringify("const fs=require('fs'),path=require('path');const dest='testcase/frontend/rag/standard-scenarios.v1.json';const candidates=[path.join('docs','templates','frontend-test-standard-scenarios.v1.json')];let src=null;for(const c of candidates){if(fs.existsSync(c)){src=c;break;}}fs.mkdirSync(path.dirname(dest),{recursive:true});if(src){fs.copyFileSync(src,dest);process.stdout.write(JSON.stringify({status:'copied',from:src,to:dest}));}else{const minimal={schemaVersion:1,id:'frontend-test-standard-scenarios-v1',scenarios:[{id:'STD-FE-SMOKE-ENTRY',title:'入口可打开',category:'smoke',priority:'must',testPoints:['open'],minCases:1}]};fs.writeFileSync(dest,JSON.stringify(minimal,null,2)+'\n');process.stdout.write(JSON.stringify({status:'fallback',to:dest}));}"),
-                    ].join(" "),
-                ],
+                commands: [],
+                frontendTestStandardScenarios: {},
                 cwd: ".",
                 timeoutMs: 60_000,
             },
@@ -5035,15 +5351,11 @@ function buildFrontendTestHybridDag(sources) {
             writeSet: ragWriteSet,
             allowedPaths: [...ragWriteSet],
             forbiddenPaths: forbidden,
-            outputContract: "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable (node ERROR so generate/map do not run).",
-            subtask_prompt: "Parse the resolved absolute baseUrl from testcase/frontend/rag/context.md, reject production/non-http(s)/credential/query/fragment URLs, then probe it with curl HEAD and GET fallback (connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. 4xx/5xx/DNS/timeout/connection refused/TLS => blockedReason frontend-base-url-unreachable. Missing curl => blockedReason curl-unavailable. Do not start the app. Fixture/reset remain soft guidance.",
+            outputContract: "Fail-closed environment preflight: absolute non-production baseUrl + curl HTTP reachability; writes environmentProbe facts; unreachable => blockedReason frontend-base-url-unreachable with errorClass (connection-refused / dns-unresolved / connect-timeout / http-N / curl-exit-N). Node ERROR so generate/map do not run. Does not start the app.",
+            subtask_prompt: "Parse the resolved absolute baseUrl from testcase/frontend/rag/context.md, reject production/non-http(s)/credential/query/fragment URLs, then probe it with curl HEAD and GET fallback (connect/max-time; no auth/cookie). 2xx/3xx => reachable and continue. Connection refused (curl 7) records errorClass=connection-refused and tells the operator to start the local app (scripts/serve.sh or npm start) then rerun from this node. 4xx/5xx/DNS/timeout/TLS => blockedReason frontend-base-url-unreachable with a distinct errorClass. Missing curl => blockedReason curl-unavailable. Do not start the app. Fixture/reset remain soft guidance.",
             shell: {
-                commands: [
-                    [
-                        "node -e",
-                        JSON.stringify(`const fs=require('fs');const {spawnSync}=require('child_process');const p='testcase/frontend/rag/context.md';const probePath='testcase/frontend/rag/environment-probe.json';function writeProbe(obj){try{fs.mkdirSync('testcase/frontend/rag',{recursive:true});fs.writeFileSync(probePath,JSON.stringify(obj,null,2)+'\\n');let ctx=fs.existsSync(p)?fs.readFileSync(p,'utf8'):'';const line='environmentProbe: '+obj.status+(obj.blockedReason?(' ('+obj.blockedReason+')'):'');if(/environmentProbe\\s*[:=]/i.test(ctx)){ctx=ctx.replace(/environmentProbe\\s*[:=]\\s*.*/i,line);}else{ctx=ctx.trimEnd()+'\\n\\n'+line+'\\n';}fs.writeFileSync(p,ctx);}catch(e){console.error('probe-write-failed',e&&e.message||e);}}function redactUrl(u){try{const x=new URL(u);x.username='';x.password='';if(x.search){x.search='';}return x.toString();}catch(_){return String(u).replace(/\\/\\/[^@\\s]+@/g,'//');}}function failBlocked(reason,extra){const payload=Object.assign({status:'unreachable',blockedReason:reason,baseUrlRedacted:extra&&extra.baseUrlRedacted||null,httpStatus:extra&&extra.httpStatus||null,method:extra&&extra.method||null,curlExit:extra&&extra.curlExit||null,errorClass:extra&&extra.errorClass||null},extra||{});writeProbe(payload);console.error('frontend-test preflight blocked: '+JSON.stringify({blockedReason:reason,baseUrl:payload.baseUrlRedacted,httpStatus:payload.httpStatus,errorClass:payload.errorClass}));throw new Error('frontend-test preflight blocked: '+reason);}if(!fs.existsSync(p))throw new Error('missing '+p);const s=fs.readFileSync(p,'utf8');const patterns=[/baseUrl\\s*[:=]\\s*["'\\x60]?((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/base[-_ ]url\\s*[:=]\\s*["'\\x60]?((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/playwright-cli open --browser=chrome\\s+((?:https?):\\/\\/[^\\s"'\\x60<>]+)/i,/(https?:\\/\\/(?:localhost|127\\.0\\.0\\.1)[^\\s)\\}\\],"']*)/i];let baseUrl=null;for(const re of patterns){const m=s.match(re);if(m){baseUrl=m[1];break;}}if(!baseUrl)throw new Error('frontend-test preflight missing absolute baseUrl from context.md');baseUrl=baseUrl.replace(/[)\\}\\],."'\\x60]+$/,'');const sourceMatch=s.match(/baseUrlSource\\s*[:=]\\s*([^\\r\\n]+)/i);const baseUrlSource=sourceMatch?sourceMatch[1].trim():'context.md';let parsed;try{parsed=new URL(baseUrl);}catch(_){throw new Error('baseUrl must be absolute http(s): '+baseUrl);}if((parsed.protocol!=='http:'&&parsed.protocol!=='https:')||parsed.username||parsed.password||parsed.search||parsed.hash)throw new Error('unsafe baseUrl from context.md: '+redactUrl(baseUrl));if(/(?:^|\\.)(?:www\\.)?[^.]*(?:prod|production)/i.test(parsed.hostname))throw new Error('production URL forbidden: '+redactUrl(baseUrl));baseUrl=parsed.toString();const safe=redactUrl(baseUrl);const curlCheck=spawnSync('curl',['--version'],{encoding:'utf8'});if(curlCheck.error||curlCheck.status!==0){failBlocked('curl-unavailable',{baseUrlRedacted:safe,errorClass:'curl-missing'});}function probe(method){const args=['-sS','-o','/dev/null','-w','%{http_code}','--connect-timeout','3','--max-time','8','-X',method,'-L','--max-redirs','3','--http1.1','--proto-redir','=http,https',safe];const r=spawnSync('curl',args,{encoding:'utf8'});return r;}let used='HEAD';let r=probe('HEAD');let code=String(r.stdout||'').trim();let statusNum=parseInt(code,10);const headRejected=r.status!==0||!statusNum||statusNum===405||statusNum===501;if(headRejected){used='GET';r=probe('GET');code=String(r.stdout||'').trim();statusNum=parseInt(code,10);}const ok=statusNum>=200&&statusNum<400;if(!ok){const errClass=r.error?'spawn-error':(r.status!==0?'curl-exit-'+r.status:('http-'+statusNum));failBlocked('frontend-base-url-unreachable',{baseUrlRedacted:safe,httpStatus:statusNum||null,method:used,curlExit:r.status,errorClass:errClass});}writeProbe({status:'reachable',blockedReason:null,baseUrl:safe,baseUrlRedacted:safe,baseUrlSource,httpStatus:statusNum,method:used,curlExit:r.status});console.log('frontend-test-execution-v1 validated contextBaseUrl='+safe+' source='+baseUrlSource+' probe=reachable method='+used+' httpStatus='+statusNum);`),
-                    ].join(" "),
-                ],
+                commands: [],
+                frontendTestEnvironmentProbe: {},
                 cwd: ".",
                 timeoutMs: 60000,
             },
@@ -5064,6 +5376,7 @@ function buildFrontendTestHybridDag(sources) {
             subtask_prompt: [
                 "Use skill playwright-cli-case-generator.",
                 "Read testcase/frontend/rag/standard-scenarios.v1.json and cover priority=must scenarios (or record GAP in coverage-map). Include ## 测试点 and ## 测试步骤 in each case.",
+                ...(uiAnchorsLedgerInstruction ? [uiAnchorsLedgerInstruction] : []),
                 "Read only testcase/frontend/rag/context.md, testcase/frontend/rag/coverage-map.md, and the draft case paths testcase/frontend/cases/FE-*.md, testcase/frontend/cases/index.md, and testcase/frontend/cases/manifest.draft.json. Write only those same draft paths. Do not write testcase/frontend/cases/manifest.json.",
                 "Generate Markdown cases, index.md and manifest.draft.json (schemaVersion 1; cases[] with caseId, casePath, dimension, acIds, evidenceDir).",
                 "HARD ID CONTRACT (do not confuse these):",
@@ -5223,7 +5536,7 @@ function buildFrontendTestHybridDag(sources) {
                 subtaskPromptTemplate: [
                     "Primary job: EXECUTE case {{case.caseId}} from {{case.casePath}} with skill playwright-cli (fresh Pi session; do not use /new). playwright-cli-only: never bare Playwright CLI/API/test runner; no fallback.",
                     "Use the structured playwright_cli tool for every browser action. Do not request or search for bash. Do not execute raw shell commands. Translate each playwright-cli line in the case Markdown into one playwright_cli tool call ({command, args?, timeoutSeconds?}).",
-                    "1) Read the concrete baseUrl from testcase/frontend/rag/context.md; it has already passed the environment shell safety/reachability gate. Start browser ONLY via playwright_cli command=open with args [--browser=chrome, <that-concrete-baseUrl>] (default session only; no -s=). 2) Dynamic refs: eX/eY in case Markdown are documentation placeholders, never tool args. Immediately before every structured playwright_cli call that references an element, parse the current real eNN from the immediately preceding latest snapshot and pass only that real eNN; never send literal `eX`/`eY`. A new snapshot invalidates prior refs, so never reuse stale refs. File outputs are canonical: screenshot args [--filename, final.png] (or [e5, --filename, final.png] for a real target), PDF args [--filename, final.pdf], and snapshot writes a file only with [--filename, snapshot.txt]; snapshot without filename is response-only. Never use --path, --output, --file, or any output path as a positional target. Follow case steps with snapshot before element refs using only playwright_cli. A passed case requires this same child receipt order: successful open → successful find → controller post-execution cleanup. Only successful find is a meaningful assertion; snapshot, goto, screenshot, request/console, click/fill and other ordinary interactions cannot establish passed authority. 3) Only when preflight or playwright_cli tool explicitly fails may you write blocked evidence (blockedReason playwright-cli-unavailable | frontend-base-url-unreachable); never invent CLI-unavailable solely because bash is absent. 4) For U/D: enforce current-user ownership / create-or-mock-or-blocked; never mutate other users' data.",
+                    "1) Read the concrete baseUrl from testcase/frontend/rag/context.md; it has already passed the environment shell safety/reachability gate. Start browser ONLY via playwright_cli command=open with args [--browser=chrome, <that-concrete-baseUrl>] (default session only; no -s=). 2) Dynamic refs: eX/eY in case Markdown are documentation placeholders, never tool args. Immediately before every structured playwright_cli call that references an element, parse the current real eNN from the immediately preceding latest snapshot and pass only that real eNN; never send literal `eX`/`eY`. A new snapshot invalidates prior refs, so never reuse stale refs. File outputs are canonical: screenshot args [--filename, final.png] (or [e5, --filename, final.png] for a real target), PDF args [--filename, final.pdf], and snapshot writes a file only with [--filename, snapshot.txt]; snapshot without filename is response-only. Never use --path, --output, --file, or any output path as a positional target. Follow case steps with snapshot before element refs using only playwright_cli. A passed case requires this same child receipt order: successful open → successful find → controller post-execution cleanup. Only successful find is a meaningful assertion; snapshot, goto, screenshot, request/console, click/fill and other ordinary interactions cannot establish passed authority. 3) Only when preflight or playwright_cli tool explicitly fails may you write blocked evidence (blockedReason playwright-cli-unavailable | frontend-base-url-unreachable); never invent CLI-unavailable solely because bash is absent. Unique-control early stop: when an AC names a specific control that is absent from the first post-navigation snapshot after reaching the required state (and no setup-required gate appeared), do ONE find with the case's literal as evidence; if it returns 0 matches, record status=blocked with blockedReason unique-control-unavailable citing that single find - do NOT re-explore with alternative literals, repeated snapshots, navigation detours, or rerun loops. 4) For U/D: enforce current-user ownership / create-or-mock-or-blocked; never mutate other users' data.",
                     "Always write {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json with caseId={{case.caseId}}, status passed|failed|blocked, evidencePaths (relative under evidenceDir). blocked needs non-empty blockedReason. After writing, self-check the same contract; if self-check fails, rewrite both files as status=blocked blockedReason=invalid-evidence-shape (never leave missing/malformed evidence).",
                     "Business failed/blocked is a recorded result, not a node failure. Close browser via playwright_cli command=close. Return compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
                 ].join("\n\n"),
@@ -5246,7 +5559,7 @@ function buildFrontendTestHybridDag(sources) {
             "const manifestPath='testcase/frontend/cases/manifest.json';",
             "if(!fs.existsSync(manifestPath)){process.stdout.write(JSON.stringify({cases:[]}));process.exit(0);}",
             "const manifest=JSON.parse(fs.readFileSync(manifestPath,'utf8'));const cases=[];",
-            "for(const c of (manifest.cases||[])){const evidenceDir=(c.evidenceDir||('testcase/frontend/evidence/'+c.caseId+'/')).replace(/\\/+$/,'')+'/';const resultPath=path.join(evidenceDir,'case-result.json');const execPath=path.join(evidenceDir,'execution.md');let reason=null;let attempt=0;let missing=false;if(!fs.existsSync(resultPath)){missing=true;reason='missing-result-files';}else{try{const r=JSON.parse(fs.readFileSync(resultPath,'utf8'));attempt=Number(r.rerunAttempt||0)||0;if(r.status==='blocked')reason='blocked';if(!r.status){missing=true;reason='missing-result-files';}}catch(_){missing=true;reason='missing-result-files';}}if(!fs.existsSync(execPath)&&reason!=='blocked'){missing=true;reason=reason||'missing-result-files';}const should=(reason==='blocked'||missing)&&attempt<" + String(round) + ";if(should){cases.push({caseId:c.caseId,casePath:c.casePath||('testcase/frontend/cases/'+c.caseId+'.md'),evidenceDir,dimension:c.dimension||'core',acIds:c.acIds||[],rerunAttempt:attempt+1,reason:reason||'blocked'});}}",
+            "for(const c of (manifest.cases||[])){const evidenceDir=(c.evidenceDir||('testcase/frontend/evidence/'+c.caseId+'/')).replace(/\\/+$/,'')+'/';const resultPath=path.join(evidenceDir,'case-result.json');const execPath=path.join(evidenceDir,'execution.md');let reason=null;let attempt=0;let missing=false;if(!fs.existsSync(resultPath)){missing=true;reason='missing-result-files';}else{try{const r=JSON.parse(fs.readFileSync(resultPath,'utf8'));attempt=Number(r.rerunAttempt||0)||0;if(r.status==='blocked')reason='blocked';if(r.status==='failed')reason='failed-retry';if(!r.status){missing=true;reason='missing-result-files';}}catch(_){missing=true;reason='missing-result-files';}}if(!fs.existsSync(execPath)&&reason!=='blocked'){missing=true;reason=reason||'missing-result-files';}const should=(reason==='blocked'||reason==='failed-retry'||missing)&&attempt<" + String(round) + ";if(should){cases.push({caseId:c.caseId,casePath:c.casePath||('testcase/frontend/cases/'+c.caseId+'.md'),evidenceDir,dimension:c.dimension||'core',acIds:c.acIds||[],rerunAttempt:attempt+1,reason:reason||'blocked'});}}",
             `fs.mkdirSync('testcase/frontend/evidence',{recursive:true});fs.writeFileSync('testcase/frontend/evidence/${candidateArtifact}',JSON.stringify({schemaVersion:1,cases},null,2)+'\\n');process.stdout.write(JSON.stringify({cases}));`,
         ].join("");
         tasks.push({
@@ -5314,6 +5627,7 @@ function buildFrontendTestHybridDag(sources) {
                         "RERUN attempt {{case.rerunAttempt}} for {{case.caseId}} (reason={{case.reason}}). Rewrite the authoritative execution.md and case-result.json; its final status replaces the earlier case result.",
                         "Primary job: EXECUTE case {{case.caseId}} from {{case.casePath}} with skill playwright-cli (fresh Pi session). Use structured playwright_cli only; headless open.",
                         "Read the concrete baseUrl from testcase/frontend/rag/context.md and start via playwright_cli command=open with args [--browser=chrome, <that-concrete-baseUrl>]. Passed requires open → find → cleanup receipts.",
+                        "Unique-control early stop: if the first post-navigation snapshot lacks the control an AC names (and no setup-required gate appeared), one find returning 0 matches is sufficient evidence - write status=blocked blockedReason unique-control-unavailable instead of exploratory retries.",
                         "Always write {{case.evidenceDir}}execution.md and {{case.evidenceDir}}case-result.json with caseId, status, evidencePaths, rerunAttempt={{case.rerunAttempt}}. Write fixed sections `### 执行摘要` and `### 实际执行步骤` to execution.md when available.",
                     ].join("\n\n"),
                 },
@@ -5449,6 +5763,7 @@ function buildFrontendTestHybridDag(sources) {
         verifyStrategy: resolveDagVerifyStrategy(sources.taskConfig),
         tasks,
     };
+    applyFrontendTestLayoutToDagSpec(spec, layout);
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
@@ -6511,15 +6826,27 @@ async function buildHybridDagForTemplate(sources, template, options = {}) {
             spec = await buildSupervisedHybridDag(standard, sources);
     }
     applyProjectGovernanceReview(spec, template, sources);
+    // Backend implementation templates only (D1 outer gate): assign the two
+    // Pi extension buckets after all template-specific nodes exist.
+    if (template === "standard-dag" ||
+        template === "review-gated-dag" ||
+        template === "supervised-implementation") {
+        applyBackendPiExtensionBuckets(spec);
+    }
     // New generate path always emits DagSpec v4 + bindings.
     spec.version = 4;
     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);
-    parseDagSpec(spec);
+    if (template === "standard-dag" ||
+        template === "review-gated-dag" ||
+        template === "supervised-implementation") {
+        stampTargetTemplateTransientRetryProfile(spec);
+    }
+    spec = parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
 }
@@ -6570,6 +6897,36 @@ export async function buildHybridDagFromTask(sources, options = {}) {
 function cloneTask(task, patch = {}) {
     return { ...task, ...patch };
 }
+/**
+ * Backend-implementation Pi extension buckets (plan 2026-08-21 D3):
+ * - read side: every non-writer, non-closeout Pi node gets navigation
+ *   extensions (pi-codegraph + pi-lens);
+ * - write side: bounded writers get only pi-codegraph (pi-lens registers
+ *   ast_grep_replace, which can bypass the writeSet — not loading it is
+ *   simpler and safer than filtering after load);
+ * - everything else (closeout, shell, static, other templates) stays closed.
+ * Idempotent: never overwrites an explicit piExtensions a task declares.
+ */
+function applyBackendPiExtensionBuckets(spec) {
+    for (const task of spec.tasks) {
+        if (task.piExtensions !== undefined)
+            continue;
+        if (task.executor !== "pi")
+            continue;
+        if (task.id === "closeout-pi")
+            continue;
+        task.piExtensions =
+            task.toolProfile === "write" ? ["pi-codegraph"] : ["pi-codegraph", "pi-lens"];
+    }
+}
+function stampTargetTemplateTransientRetryProfile(spec) {
+    for (const task of spec.tasks) {
+        if (isTargetTemplateImplementPi(task) ||
+            isCanonicalFinalVerifyShellRetryCandidate(task)) {
+            task.transientRetryProfile = TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE;
+        }
+    }
+}
 /**
  * Apply default Pi retry policies to generated DAG nodes:
  * - safe read-only planner/scout/reviewer/verifier/supervisor/closeout
@@ -6590,6 +6947,10 @@ function applyDefaultReadOnlyRetryPolicy(spec) {
                     : DEFAULT_READ_ONLY_PI_RETRY_POLICY;
             continue;
         }
+        if (isTargetTemplateImplementPi(task)) {
+            task.retryPolicy = TARGET_TEMPLATE_WRITER_TRANSPORT_RETRY_POLICY;
+            continue;
+        }
         if (isWriterTransportRetryCandidate(task)) {
             task.retryPolicy = WRITER_TRANSPORT_RETRY_POLICY;
         }
@@ -6850,6 +7211,7 @@ function buildReviewGatedHybridDag(standard, sources) {
     }));
     spec.tasks.splice(spec.tasks.length - 1, 0, buildReviewNode(sources), buildReviewVerdictRecoveryNode(sources), buildReviewGateNode(sources));
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    stampTargetTemplateTransientRetryProfile(spec);
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
@@ -7181,6 +7543,9 @@ async function buildHardVerifyNode(sources) {
         forbiddenPaths: commonForbiddenPaths(sources),
         outputContract: "Archived hard verification stdout/stderr with exit codes; no worktree writes.",
         subtask_prompt: "Run hard verification after repair round.",
+        transientRetryProfile: sources.verifyCommands && commands.length > 0
+            ? TARGET_TEMPLATE_TRANSIENT_RETRY_PROFILE
+            : undefined,
         shell: {
             commands,
             verifyEvidence: buildVerifyEvidence({
@@ -7351,6 +7716,7 @@ async function buildSupervisedHybridDag(standard, sources) {
         ],
     };
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    stampTargetTemplateTransientRetryProfile(spec);
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);