@tea-agent/loop-agent 0.39.0-beta.2 → 0.39.0-beta.3

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

@@ -8,10 +8,10 @@ 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 { 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, 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, 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,9 +19,8 @@ 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 { dagHasWriterExecution } from "./task-contract-binding.js";
 import { DEFAULT_VERIFY_TIMEOUT_MS, resolveVerifyPreset, } from "../../executors/shell-verification.js";
@@ -33,8 +32,11 @@ import { buildBackendTestOutcomeGateShellSnippet } from "./backend-test-result-c
 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, FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } 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";
@@ -216,6 +218,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 +1306,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 +1331,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 +1409,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 +1482,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;
     }
@@ -1502,27 +1575,11 @@ function buildSourceContextBlock(sources) {
             .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) {
@@ -1530,21 +1587,6 @@ function buildSourceContextBlock(sources) {
     }
     return parts.join("\n\n");
 }
-/**
- * Planner/reviewer nodes already receive the contract/scout artifacts. They
- * only need stable task-source pointers for an unresolved or conflicting
- * field, not a second inline copy of every fact-source document.
- */
-function buildArtifactFirstSourceAccessBlock(sources) {
-    const binding = buildDagSourceBinding(sources);
-    return [
-        "## Bound task-source access (read only when upstream artifacts are missing or conflict)",
-        ...binding.sources.map((source) => `- ${source.kind}: ${source.path}`),
-        "Use these exact repository-readable paths. Do not search for substitutes or read runtime implementation code to diagnose a format retry.",
-        `- taskId: ${binding.taskId}`,
-        `- allowedPaths: ${sources.taskConfig.allowedPaths.join(", ") || "(none)"}`,
-    ].join("\n");
-}
 async function loadMaterializedSourceReferences(sourceDir) {
     const referenceDir = path.join(sourceDir, REFERENCE_DIRECTORY);
     const referencePaths = [];
@@ -1575,49 +1617,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);
@@ -1698,6 +1701,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,
@@ -1714,6 +1727,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         verifyCommands,
         sddEmbeddedSkills: await probeRepoLocalSddSkills(repoRoot),
         projectGovernancePresent: await discoverProjectGovernancePresence(repoRoot),
+        ...(frontendShapeTransitionCapsule ? { autoloadedFrontendShapeTransitionCapsule: frontendShapeTransitionCapsule } : {}),
     };
     return sources;
 }
@@ -1731,7 +1745,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,
@@ -1790,6 +1806,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({
@@ -1910,6 +1927,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.",
@@ -1969,6 +1987,7 @@ export function buildStandardHybridDagFromTask(sources) {
         ],
     };
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    stampTargetTemplateTransientRetryProfile(spec);
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
@@ -2237,11 +2256,18 @@ function frontendMockStrategyMustBeNotNeeded(sources) {
             capabilityStatus === "ambiguous" ||
             !hasDeterministicMockVerification));
 }
-function resolveFrontendOpenspecGateConfig(sources) {
+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 dedupeSorted = (paths) => [...new Set(paths)].sort();
     const openspecCandidateSources = {
@@ -2249,20 +2275,30 @@ function resolveFrontendOpenspecGateConfig(sources) {
         taskSourceCited: dedupeSorted(taskSourceCited),
         scanStrict: dedupeSorted(scanStrict),
     };
-    const openspecCandidatePaths = policy === "cited"
-        ? dedupeSorted([...declared, ...taskSourceCited])
-        : openspecCandidateSources.scanStrict;
-    return {
+    // Candidate discovery is frozen independently from the eventual must-read
+    // set. The selector may mark candidates irrelevant, while explicit task
+    // declarations/source citations are never allowed to be downgraded.
+    const openspecMandatoryPaths = dedupeSorted([...declared, ...taskSourceCited]);
+    const openspecCandidatePaths = dedupeSorted([
+        ...openspecCandidateSources.scanStrict,
+        ...openspecMandatoryPaths,
+    ]);
+    const result = {
         openspecPolicy: policy,
         openspecCandidatePaths,
         openspecCandidateSources,
+        openspecMandatoryPaths,
     };
+    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 }。",
@@ -2270,7 +2306,7 @@ const frontendComponentConformanceInstruction = [
     "- decision=reuse-existing：复用仓库既有组件/惯例（规范未点名）→ specReference 可为 null，rationale 说明复用的现有组件与依据。",
     "- decision=new：规范与既有代码均无合适组件 → specReference 必须为 null，rationale 必须说明偏差理由（design-review 审，最终 review 复核）。",
     "不得静默替换规范组件或自创组件而无偏差声明；spec 已定义该用途组件时不得改选其它组件。",
-    "prewrite gate 确定性交叉校验：specReference.path 非法 → component-spec-reference-invalid；未在 openspec-citations 引用块中引用或未真实读取 → component-spec-not-cited；候选桶非空且契约有 UI 可见工作而 uiComponentChoices 缺失/空 → component-choices-missing。",
+    "prewrite gate 确定性交叉校验：specReference.path 非法 → component-spec-reference-invalid；specReference.path 未在 typed decision ledger 中声明或缺少成功 read 事件 → component-spec-not-cited；候选桶非空且契约有 UI 可见工作而 uiComponentChoices 缺失/空 → component-choices-missing。",
 ].join("\n");
 function resolveFrontendCapabilityContextBlock(sources) {
     const risk = sources.frontendRisk;
@@ -2320,17 +2356,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) => {
@@ -2338,11 +2459,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);
         }
@@ -2350,30 +2468,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);
             }
@@ -2398,9 +2513,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 ?? {
@@ -2425,6 +2554,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,
@@ -2433,6 +2567,19 @@ async function buildFrontendHybridDagFromTask(sources) {
             allowedPaths: taskConfig.allowedPaths,
             complexity: taskConfig.complexity,
         });
+    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);
     const frontendContractSkeleton = buildFrontendImplementationContractSkeleton({
         sourceBinding: frontendSourceBinding,
@@ -2448,7 +2595,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             "## 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.",
+            "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 writes a hash-bound canonical JSON artifact; downstream review and prewrite consume that artifact path, not planner stdout.",
             "",
             "## Forbidden fields (these are NOT in the schema; do not emit)",
             "- schemaId",
@@ -2461,6 +2608,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             "- 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)",
+            "- dependencyPolicy must declare whether new dependencies are introduced: use a clear negative（零新增依赖/不引入新依赖）or an explicit allowlist phrase（仅使用已声明的 X、Y）。Plain prose that merely mentions tool names without declaring new deps is still enforced by the policy shell against the project package.json allowlist; an undeclared new dependency is rejected.",
             "- 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.",
             "",
@@ -2521,7 +2669,7 @@ async function buildFrontendHybridDagFromTask(sources) {
     })();
     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:",
+        "The plan node emits only a fenced json contract patch; frontend-design-policy-shell applies the runtime skeleton, validates, and materializes the canonical full contract JSON. There is no Markdown plan explanation to read. Review these fields:",
         "- requirements[]: id, expectedOutcome, implementationTargets, verificationTargetIds, evidenceGap",
         "- uiStates[]: name, applicable, expectedBehavior, implementationTargets, verificationTargetIds, notApplicableReason",
         "- interactions[]: name, trigger, expectedBehavior, implementationTargets, verificationTargetIds",
@@ -2533,34 +2681,30 @@ async function buildFrontendHybridDagFromTask(sources) {
         "- 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.",
-        "Each behavior belongs to one primary row: requirements cover acceptance, uiStates cover only distinct visible states, and interactions cover only distinct user triggers. Link with IDs; do not restate the same prose in all three. Steps are action plus files, not a prose mirror. Omit optional fields when upstream contract/scout facts already settle them, and omit unchanged revision fields.",
-        "Enums: mock strategy native|browser-intercept|request-adapter|not-needed; uiComponentChoices decision specified|reuse-existing|new. Omit optional empty strings.",
-    ].join("\n");
     const sourceContext = [
         buildSourceContextBlock(sources),
         capabilityContextBlock,
     ]
         .filter(Boolean)
         .join("\n\n");
-    const artifactFirstSourceContext = [
-        buildArtifactFirstSourceAccessBlock(sources),
-        capabilityContextBlock,
-    ]
-        .filter(Boolean)
-        .join("\n\n");
     const hasMockVerifyCommands = (taskConfig.frontendMock?.verifyCommands.length ?? 0) > 0 ||
         mockCapability.verifyCommands.length > 0;
     const requirementIds = frontendSourceBinding.requirementIds;
     const requirementCoverageInstruction = requirementIds.length > 0
         ? [
-            "## Requirement Coverage",
-            `Cover each frozen ID exactly once in requirements[]: ${requirementIds.join(", ")}. Each item needs a concrete expectedOutcome, implementationTargets, and verificationTargetIds.`,
-            "Interactions need trigger + expectedBehavior; applicable uiStates need expectedBehavior + implementationTargets + verificationTargetIds. Do not use empty strings.",
+            `## 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 = [
@@ -2568,16 +2712,11 @@ async function buildFrontendHybridDagFromTask(sources) {
         `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 plannerSourceReadInstruction = [
-        "## Source-read policy",
-        "Use frontend-contract-pi and frontend-scout-pi artifacts as primary evidence. Do not repeat reads that those facts already settle.",
-        "Read a bound source only to resolve a missing or conflicting field; read every applicable OpenSpec candidate directly before citing it. Never infer omitted task fields from a preview.",
+        ``,
+        `verificationTargets[].symbol semantics (deterministic runtime strip):`,
+        `- Static targets MUST NOT declare a symbol at all: the runtime strips any symbol from static targets (project-wide commands verify by exit code, never by a per-file symbol).`,
+        `- Non-static targets MUST declare the symbol they verify: an exported function/component/variable name, or a describe/it title exactly as written in that file. The trace gate resolves it against the file after verification.`,
+        `- Never emit placeholder tokens ("null", "undefined", "n/a", "tbd", "...", "?", "-") or long prose fragments as symbols; a fabricated symbol fails plan validation and costs a retry round.`,
     ].join("\n");
     const strategy = resolveDagVerifyStrategy(taskConfig);
     const readOnlyPaths = taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"];
@@ -2588,15 +2727,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."
@@ -2612,7 +2751,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,
@@ -2711,11 +2857,24 @@ 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;
+    const openspecSelectionContext = JSON.stringify({
+        schemaVersion: 1,
+        schemaId: "frontend-openspec-selection-v1",
+        candidates: openspecGate.openspecCandidatePaths,
+        mandatoryPaths: openspecGate.openspecMandatoryPaths,
+    });
     // 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
@@ -2727,23 +2886,12 @@ async function buildFrontendHybridDagFromTask(sources) {
         ...(classified?.theme ?? []),
         ...(classified?.rule.components ?? []),
     ].filter((value, index, array) => array.indexOf(value) === index).sort();
-    const frontendPlanCitationsRequired = openspecGate.openspecCandidatePaths.length > 0 ||
-        componentSpecCandidatePaths.length > 0;
-    const frontendPlanCitationInstruction = frontendPlanCitationsRequired
-        ? openspecCitationInstruction
-        : "The generation-frozen OpenSpec/component candidate set is empty. Do not read, cite, or emit an openspec-citations fence; output only the primary JSON patch. The runtime records an empty citation artifact deterministically.";
-    const frontendPlanOutputContract = frontendPlanCitationsRequired
-        ? "JSON-only patch output: exactly ONE fenced json object (```json ... ```) containing only the editable RFC 7386 plan patch for the runtime contract skeleton, immediately followed by exactly one ```openspec-citations``` fenced citation block. Omit protected fields: schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. 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."
-        : "JSON-only patch output: exactly ONE fenced json object (```json ... ```) containing only the editable RFC 7386 plan patch for the runtime contract skeleton. The generation-frozen OpenSpec candidate set is empty, so do NOT emit an openspec-citations fence. Omit protected fields: schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. 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.";
-    const frontendRevisionOutputContract = frontendPlanCitationsRequired
-        ? "When the initial design review requests revision, return 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 followed by 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."
-        : "JSON-only output: when the initial design review requests revision, return 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). The generation-frozen OpenSpec candidate set is empty, so do NOT emit an openspec-citations fence. Do NOT emit a full contract, Markdown explanation, prose, or another fenced block. No file writes.";
     if (openspecGate.openspecPolicy === "cited") {
         if (openspecGate.openspecCandidatePaths.length === 0) {
             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 {
@@ -2781,12 +2929,20 @@ 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, 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, also append the openspec classification and one final fenced frontend-openspec-selection-v1 JSON object. 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 a stable REQ/BR/AC identifier and a source span (task-source section or repository file:line). Label each requirement's disposition as explicit | repository-resolvable | assumption | blocking; a blocking requirement must name its owner (human-decision or external-state) and evidence refs.",
+                    "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.",
+                    ...(requiresOpenspecClassification ? [
+                        "Classify every generation-frozen OpenSpec candidate while contracting: required must be read and cited by the plan; relevant may inform planning but is not forced; irrelevant is out of scope. mandatoryPaths MUST be required and cannot be downgraded.",
+                        "After the Markdown contract, append exactly one fenced json object with schemaVersion 1, schemaId frontend-openspec-selection-v1, and selections [{path,disposition,rationale}]. No other JSON fences.",
+                        openspecSelectionContext,
+                    ] : []),
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
-                    mandatorySourceReadInstruction,
                     sourceContext,
                 ].join("\n\n"),
             },
@@ -2800,11 +2956,11 @@ async function buildFrontendHybridDagFromTask(sources) {
                 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. 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): entrypoint, routeOrMount, implementationPaths, testPaths, dataSource, allowedPathConflicts. Use repository-relative POSIX paths. implementationPaths and testPaths must name the existing files/directories that actually own the requested behavior; allowedPathConflicts must list every discovered path not covered by task allowedPaths, or [] when none exists.",
                     "Derive all file paths from this target workspace. Do not assume the project uses src/, test/, React, or the loop-agent repository layout.",
                     "Read-only: do not modify repository files.",
                     sourceContext,
@@ -2817,254 +2973,196 @@ 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,
+                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,
-                    citationsRequired: frontendPlanCitationsRequired,
                 },
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                skills: [],
-                outputContract: frontendPlanOutputContract,
+                outputContract: "Short Markdown narrative plus incremental typed plan record tools (record_target_surface / record_component_choice / record_state_flow / record_data_flow / record_mock_api / record_design_deviation / record_dependency) and exactly one finalize_plan terminal call. finalize_plan assembles the canonical editable patch from committed facts (requirements / verificationTargets / evidenceGaps / implementationSteps / residualRisks / realIntegrationGap). Omit protected fields: schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff. The runtime compiles facts ⊕ skeleton into canonical full-contract JSON for downstream review. No 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.",
+                    "Use frontend-contract-pi typed requirement facts (stable REQ/BR/AC identifiers, dispositions, evidence expectations, and frontend-test handoff intents), frontend-scout-pi, task sources, and the generation-time Mock capability evidence to fill the runtime-owned frontend contract skeleton. Record the plan decision ledger through the incremental record_* tools, then call finalize_plan exactly once. The runtime already owns schemaVersion, sourceBinding, riskLevel, targets.files, and mockApi.productionDefaultOff; omit those protected paths even when their values look obvious.",
+                    ...(requiresOpenspecClassification ? ["Additionally consume the frontend-contract-pi openspec classification. Successfully read every required selection (including mandatory paths) and declare any used component specReference in the typed decision ledger; relevant/irrelevant selections are not forced into the ledger unless the plan actually uses them."] : []),
+                    "The incremental record_* facts become the complete implementation plan after deterministic merge with the protected skeleton. Do not treat leftover JSON in the narrative as the compile authority.",
+                    "Select the Mock / API strategy only through record_mock_api. Encode endpoint/fixture mapping, explicit activation, verification commands, and Real Integration Gap in schema-defined 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 ledger payload. 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.",
-                    frontendPlanCitationsRequired
-                        ? "Output exactly two adjacent blocks: (1) one fenced json object containing the editable plan patch; (2) one openspec-citations citation block."
-                        : "Output exactly one fenced json object containing the editable plan patch; do not emit an openspec-citations block.",
-                    "Do NOT emit protected skeleton fields, a full contract, Markdown plan explanation, raw JSON, or any other fenced block.",
+                    "Consume the Scout target surface and design 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 a short Markdown narrative, record the incremental facts, then call finalize_plan exactly once. Do NOT emit protected skeleton fields or a full contract as the authority.",
                     "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.",
+                    "Attribution rule (hard pre-check): every interaction.name and every applicable uiState.name must have a uiComponentChoices entry whose purpose exactly matches that name; a non-empty stylingStrategy additionally covers applicable visual UI states. Missing attribution fails the plan policy pre-check with a retryable diagnostic.",
                     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.",
-                    plannerSourceReadInstruction,
                     fixedVerificationContext,
-                    artifactFirstSourceContext,
+                    sourceContext,
                     mockContextBlock,
-                    frontendPlanFieldGuide,
+                    frontendContractSchemaBlock,
                     frontendComponentConformanceInstruction,
-                    frontendPlanCitationInstruction,
                 ].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,
-                    artifactFirstSourceContext,
-                    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,
-                    citationsRequired: frontendPlanCitationsRequired,
+                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: frontendRevisionOutputContract,
-                subtask_prompt: [
-                    "Consume the hash-bound frontend-plan-pi contract artifact and frontend-design-review-pi findings. Read the artifact only for fields affected by a Required Plan Correction.",
-                    "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.",
-                    "Only include changed fields. For a changed requirement, preserve its expectedOutcome, implementationTargets, and verificationTargetIds; do not resend unchanged requirements.",
-                    "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.",
-                    frontendPlanCitationsRequired
-                        ? "Output exactly two adjacent blocks: (1) one fenced json object containing the merge-patch delta; (2) one openspec-citations citation block."
-                        : "JSON-only: output exactly one fenced json object containing the merge-patch delta; do not emit an openspec-citations block.",
-                    "Do NOT emit a full contract, Markdown explanation, prose, raw JSON or JSON objects outside the fenced payload, 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,
-                    artifactFirstSourceContext,
-                    frontendPlanFieldGuide,
-                    mockContextBlock,
-                    frontendComponentConformanceInstruction,
-                    frontendPlanCitationInstruction,
-                ].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",
-                ],
                 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; or when any uiComponentChoices specReference.path is missing a ledger specReference or has no successful 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.",
                     fixedVerificationContext,
-                    artifactFirstSourceContext,
+                    sourceContext,
                     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.",
@@ -3079,7 +3177,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     .join("\n\n"),
             },
             {
-                id: "frontend-verify-assess-shell",
+                id: "frontend-verify-shell",
                 depends_on: [implementId],
                 role: "verifier",
                 executor: "shell",
@@ -3087,8 +3185,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: {
@@ -3102,7 +3200,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",
@@ -3111,85 +3209,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 },
@@ -3207,76 +3237,61 @@ async function buildFrontendHybridDagFromTask(sources) {
                 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 (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.",
                     "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})`,
+    ];
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
@@ -4871,6 +4886,13 @@ 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, "testcase/frontend/rag/ui-anchors.md")));
+    const uiAnchorsLedgerInstruction = hasUiAnchorsLedger
+        ? "Also read testcase/frontend/rag/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;
@@ -4911,6 +4933,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-*'});",
@@ -4929,6 +4953,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'});",
         "  }",
         " }",
@@ -4960,6 +4985,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);",
@@ -4967,7 +4994,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)); }",
@@ -5027,15 +5054,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,
             },
@@ -5071,15 +5094,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,
             },
@@ -5100,6 +5119,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):",
@@ -5259,7 +5279,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"),
@@ -5282,7 +5302,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({
@@ -5350,6 +5370,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"),
                 },
@@ -6547,6 +6568,13 @@ 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) {
@@ -6555,7 +6583,12 @@ async function buildHybridDagForTemplate(sources, template, options = {}) {
     spec.sourceBinding = buildDagSourceBinding(sources);
     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;
 }
@@ -6606,6 +6639,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
@@ -6626,6 +6689,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;
         }
@@ -6886,6 +6953,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);
@@ -7217,6 +7285,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({
@@ -7387,6 +7458,7 @@ async function buildSupervisedHybridDag(standard, sources) {
         ],
     };
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    stampTargetTemplateTransientRetryProfile(spec);
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);