@tea-agent/loop-agent 0.13.0-beta.0 → 0.13.0

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

@@ -1,12 +1,13 @@
 import { createHash } from "node:crypto";
-import { access, readdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { access, readdir, readFile, realpath, writeFile, } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { assertValidDagSpec } from "./validate.js";
 import { DAG_AGENT_RUNTIME_PI_ONLY, DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1, DAG_RUNTIME_CONTRACT_SCHEMA_VERSION, DEFAULT_DAG_OUTPUT_LANGUAGE, DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
-import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate } from "./retry-policy.js";
+import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
+import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
@@ -16,6 +17,10 @@ import { materializeTaskReferenceDocs } from "../../task/source-references.js";
 import { resolveVerifyPreset } from "../../executors/shell-verification.js";
 import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
 import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "./task-demand-routing.js";
+import { BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT, buildBackendTestExecutionPreflightShellSnippet, } from "./backend-test-execution-contract.js";
+import { buildBackendTestOutcomeGateShellSnippet } from "./backend-test-result-contract.js";
+import { classifyFrontendRisk, } from "./frontend-risk.js";
+import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
 const REFERENCE_DIRECTORY = "references";
@@ -185,7 +190,10 @@ async function hasDirectDependency(repoRoot, depName) {
     try {
         const raw = await readFile(path.join(repoRoot, "package.json"), "utf-8");
         const pkg = JSON.parse(raw);
-        const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+        const deps = {
+            ...(pkg.dependencies ?? {}),
+            ...(pkg.devDependencies ?? {}),
+        };
         return depName in deps;
     }
     catch {
@@ -207,7 +215,10 @@ async function discoverMockHandlerFiles(repoRoot, serviceRoot) {
             "mocks/browser.ts",
             "mocks/browser.js",
         ].map((candidatePath) => ({ framework: "msw", path: candidatePath })),
-        ...["db.json", "mock/db.json", "src/mock/db.json"].map((candidatePath) => ({ framework: "json-server", path: candidatePath })),
+        ...["db.json", "mock/db.json", "src/mock/db.json"].map((candidatePath) => ({
+            framework: "json-server",
+            path: candidatePath,
+        })),
     ];
     const directoryCandidates = [
         ...(serviceRoot ? [{ path: serviceRoot }] : []),
@@ -331,7 +342,13 @@ export async function discoverFrontendMockCapability(repoRoot, taskConfig) {
         // A script alone is not strong evidence unless we also find config/entry
     }
     // 2. Check for direct mock framework dependencies
-    const mockDeps = ["msw", "mockjs", "miragejs", "json-server", "vite-plugin-mock"];
+    const mockDeps = [
+        "msw",
+        "mockjs",
+        "miragejs",
+        "json-server",
+        "vite-plugin-mock",
+    ];
     const foundDeps = [];
     for (const dep of mockDeps) {
         if (await hasDirectDependency(repoRoot, dep)) {
@@ -385,7 +402,9 @@ export async function discoverFrontendMockCapability(repoRoot, taskConfig) {
         if (foundDeps.length > 0 && handlerResult.paths.length === 0) {
             reasons.push(`Mock dependency found (${foundDeps.join(", ")}) but no handler/bootstrap files detected`);
         }
-        if (scriptResult.hasScript && handlerResult.paths.length === 0 && foundDeps.length === 0) {
+        if (scriptResult.hasScript &&
+            handlerResult.paths.length === 0 &&
+            foundDeps.length === 0) {
             reasons.push("Mock scripts exist but no handler files or direct mock dependencies found");
         }
     }
@@ -396,8 +415,11 @@ export async function discoverFrontendMockCapability(repoRoot, taskConfig) {
         cwd: repoRoot,
         timeoutMs: cmd.timeoutMs,
     }));
-    const verifyCommands = [...configuredVerifyCommands, ...scriptResult.verifyCommands]
-        .filter((command, index, commands) => commands.findIndex((candidate) => candidate.label === command.label) === index);
+    const verifyCommands = [
+        ...configuredVerifyCommands,
+        ...scriptResult.verifyCommands,
+    ].filter((command, index, commands) => commands.findIndex((candidate) => candidate.label === command.label) ===
+        index);
     if (strongEvidenceCount > 0) {
         return {
             status: "present",
@@ -475,7 +497,10 @@ async function frontendMockServiceRootSafetyViolation(repoRoot, taskConfig) {
         if (!frontendMockServiceRootAllowed({
             ...taskConfig,
             frontendMock: {
-                ...(taskConfig.frontendMock ?? { policy: "auto", verifyCommands: [] }),
+                ...(taskConfig.frontendMock ?? {
+                    policy: "auto",
+                    verifyCommands: [],
+                }),
                 serviceRoot: normalizedRealPath,
             },
         })) {
@@ -504,8 +529,7 @@ export function hasApiDependency(sources) {
     if (sources.taskConfig.frontendMock?.policy === "required") {
         return true;
     }
-    const requirement = normalizeTaskRequirementText(sources.requirementMarkdown)
-        .replace(/`[^`\n]*`/g, " ");
+    const requirement = normalizeTaskRequirementText(sources.requirementMarkdown).replace(/`[^`\n]*`/g, " ");
     const dependencyPatterns = [
         /(?:接口文档|接口定义|接口协议|后端接口|服务端接口|接口联调|请求|响应|远程数据|异步数据|数据获取|模拟接口|模拟数据)/,
         /(?<![A-Za-z0-9_])API(?![A-Za-z0-9_])/i,
@@ -539,7 +563,8 @@ export function hasApiDependency(sources) {
 export function resolveFrontendMockMode(capability, taskConfig, hasApiDep) {
     const policy = taskConfig.frontendMock?.policy ?? "auto";
     const hasDeterministicMockVerification = capability.verifyCommands.length > 0;
-    if (capability.safetyViolation || !frontendMockServiceRootAllowed(taskConfig)) {
+    if (capability.safetyViolation ||
+        !frontendMockServiceRootAllowed(taskConfig)) {
         return "blocked";
     }
     // disabled policy: must respect project mock rules (can't override spec)
@@ -615,7 +640,8 @@ function isMetadataLine(line) {
     }
     if (/^(权威来源|SHA-256|冲突时以)/.test(trimmed))
         return true;
-    if (/^>/.test(trimmed) && /(权威来源|SHA-256|原始 PRD|reference)/i.test(trimmed)) {
+    if (/^>/.test(trimmed) &&
+        /(权威来源|SHA-256|原始 PRD|reference)/i.test(trimmed)) {
         return true;
     }
     return false;
@@ -702,7 +728,9 @@ function shellQuote(value) {
 }
 function verifyCommandToShell(repoRoot, command) {
     const relativeCwd = path.relative(repoRoot, command.cwd);
-    const cwdPrefix = relativeCwd && !relativeCwd.startsWith("..") && !path.isAbsolute(relativeCwd)
+    const cwdPrefix = relativeCwd &&
+        !relativeCwd.startsWith("..") &&
+        !path.isAbsolute(relativeCwd)
         ? `cd ${shellQuote(relativeCwd)} && `
         : command.cwd !== repoRoot
             ? `cd ${shellQuote(command.cwd)} && `
@@ -851,9 +879,7 @@ function deriveFrontendBehaviorPaths(taskConfig) {
     return taskConfig.allowedPaths;
 }
 function toTaskRelativeSourcePath(sources, absolutePath) {
-    return path
-        .relative(sources.taskDir, absolutePath)
-        .replaceAll(path.sep, "/");
+    return path.relative(sources.taskDir, absolutePath).replaceAll(path.sep, "/");
 }
 function extractExplicitRequirementIds(...markdownInputs) {
     const ids = [];
@@ -873,9 +899,25 @@ function extractExplicitRequirementIds(...markdownInputs) {
 }
 function buildDagSourceBinding(sources) {
     const sourceEntries = [
-        { kind: "requirement", path: sources.requirementPath, markdown: sources.requirementMarkdown },
-        ...(sources.constraintMarkdown ? [{ kind: "constraint", path: sources.constraintPath, markdown: sources.constraintMarkdown }] : []),
-        ...(sources.referenceDocuments ?? []).map((reference) => ({ kind: "reference", path: reference.path, markdown: reference.markdown })),
+        {
+            kind: "requirement",
+            path: sources.requirementPath,
+            markdown: sources.requirementMarkdown,
+        },
+        ...(sources.constraintMarkdown
+            ? [
+                {
+                    kind: "constraint",
+                    path: sources.constraintPath,
+                    markdown: sources.constraintMarkdown,
+                },
+            ]
+            : []),
+        ...(sources.referenceDocuments ?? []).map((reference) => ({
+            kind: "reference",
+            path: reference.path,
+            markdown: reference.markdown,
+        })),
     ];
     return {
         schemaVersion: 1,
@@ -883,7 +925,9 @@ function buildDagSourceBinding(sources) {
         sources: sourceEntries.map((source) => ({
             kind: source.kind,
             path: toTaskRelativeSourcePath(sources, source.path),
-            sha256: createHash("sha256").update(source.markdown, "utf8").digest("hex"),
+            sha256: createHash("sha256")
+                .update(source.markdown, "utf8")
+                .digest("hex"),
         })),
         requirementIds: extractExplicitRequirementIds(sources.requirementMarkdown, sources.constraintMarkdown, ...(sources.referenceDocuments ?? []).map((reference) => reference.markdown)),
     };
@@ -893,10 +937,7 @@ function buildSourceContextBlock(sources) {
     const requirementExcerpt = excerptMarkdown(sources.requirementMarkdown, {
         sourceRef: requirementRef,
     });
-    const parts = [
-        "## Task source: 需求.md",
-        requirementExcerpt.text,
-    ];
+    const parts = ["## Task source: 需求.md", requirementExcerpt.text];
     if (sources.constraintMarkdown) {
         const constraintRef = toTaskRelativeSourcePath(sources, sources.constraintPath);
         const constraintExcerpt = excerptMarkdown(sources.constraintMarkdown, {
@@ -940,7 +981,8 @@ async function loadMaterializedSourceReferences(sourceDir) {
             }
             else if (entry.isFile()) {
                 // Skip index/manifest sidecars; keep only user/source reference content.
-                if (entry.name === "index.json" || entry.name === "source-manifest.json") {
+                if (entry.name === "index.json" ||
+                    entry.name === "source-manifest.json") {
                     continue;
                 }
                 referencePaths.push(entryPath);
@@ -949,7 +991,9 @@ async function loadMaterializedSourceReferences(sourceDir) {
     }
     await collect(referenceDir);
     referencePaths.sort((left, right) => left.localeCompare(right));
-    return Promise.all(referencePaths.slice(0, MAX_SOURCE_REFERENCE_DOCUMENTS).map(async (filePath) => ({
+    return Promise.all(referencePaths
+        .slice(0, MAX_SOURCE_REFERENCE_DOCUMENTS)
+        .map(async (filePath) => ({
         path: filePath,
         markdown: await readFile(filePath, "utf-8"),
     })));
@@ -1043,10 +1087,26 @@ async function prepareFrontendMockSources(sources) {
             capability.verifyCommands.push(command);
         }
     }
+    const projectCapability = await discoverFrontendProjectCapability(repoRoot);
+    const frontendRisk = classifyFrontendRisk({
+        title: sources.taskConfig.title,
+        requirementMarkdown: sources.requirementMarkdown,
+        constraintMarkdown: sources.constraintMarkdown ?? undefined,
+        allowedPaths: sources.taskConfig.allowedPaths,
+        forbiddenPaths: sources.taskConfig.forbiddenPaths,
+        complexity: sources.taskConfig.complexity,
+        manifestEvidence: [
+            projectCapability.framework,
+            projectCapability.frameworkVersion ?? "",
+            projectCapability.adapterGuidance,
+        ].join("\n"),
+    });
     return {
         ...sources,
         frontendMockCapability: capability,
         frontendMockMode: resolveFrontendMockMode(capability, sources.taskConfig, hasApiDependency(sources)),
+        frontendProjectCapability: projectCapability,
+        frontendRisk,
     };
 }
 function mergeFinalVerifyCommands(repoRoot, taskConfig, adapterCommands) {
@@ -1080,14 +1140,17 @@ export function buildStandardHybridDagFromTask(sources) {
         fallbackCommands: [],
     });
     const verifyShellTask = verifyShellCommands.length > 0
-        ? [{
+        ? [
+            {
                 id: "verify-shell",
                 depends_on: [implementId],
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
-                allowedPaths: taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"],
+                allowedPaths: taskConfig.allowedPaths.length > 0
+                    ? taskConfig.allowedPaths
+                    : ["**"],
                 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.",
@@ -1104,7 +1167,8 @@ export function buildStandardHybridDagFromTask(sources) {
                     cwd: ".",
                     timeoutMs: 300000,
                 },
-            }]
+            },
+        ]
         : [];
     const sourceContext = buildSourceContextBlock(sources);
     const globalConstraints = [
@@ -1209,7 +1273,9 @@ export function buildStandardHybridDagFromTask(sources) {
                     "Stay within writeSet. Do not write root artifacts/** unless artifacts paths are explicitly declared in writeSet.",
                     writerDeliveryContract(taskConfig),
                     sourceContext,
-                ].filter((value) => Boolean(value)).join("\n\n"),
+                ]
+                    .filter((value) => Boolean(value))
+                    .join("\n\n"),
             },
             ...verifyShellTask,
             {
@@ -1505,13 +1571,131 @@ function resolveFrontendMockContextBlock(sources) {
     }
     return parts.join("\n");
 }
+function resolveFrontendCapabilityContextBlock(sources) {
+    const risk = sources.frontendRisk;
+    const capability = sources.frontendProjectCapability;
+    const parts = ["## Frontend risk & project capability", ""];
+    if (risk) {
+        parts.push(`Risk level: ${risk.selectedRisk}`, `Risk reason: ${risk.reason}`, `Risk signals: ${risk.signals.join(", ") || "(none)"}`, `Rejected signals: ${risk.rejectedSignals.join(", ") || "(none)"}`, `Force full gates: ${risk.forceFullGates}`);
+    }
+    else {
+        parts.push("Risk level: standard (not precomputed)");
+    }
+    if (capability) {
+        parts.push("", capability.adapterGuidance);
+        if (capability.designEvidence.normativePaths.length > 0) {
+            parts.push(`openSpec normative candidates: ${capability.designEvidence.normativePaths.slice(0, 12).join(", ")}`);
+        }
+        parts.push(`A11y capability: ${capability.a11y.status}` +
+            (capability.a11y.tools.length
+                ? ` (${capability.a11y.tools.join(", ")})`
+                : ""));
+        parts.push("Browser accessibility verification: not-run (out of scope for this workflow).");
+    }
+    return parts.join("\n");
+}
+function pruneFrontendTasksForRisk(tasks, risk) {
+    if (risk.forceFullGates || risk.selectedRisk !== "small") {
+        return tasks;
+    }
+    // small topology: drop first design gate + plan revision + second design cycle;
+    // keep mock assess/gate, single design review (final), contract, implement, verify, repair chain, review.
+    const drop = new Set([
+        "frontend-design-gate-pi",
+        "frontend-first-design-gate-shell",
+        "frontend-plan-revision-pi",
+    ]);
+    // If we drop plan-revision, contract shell must depend on plan-pi instead; final design review depends on plan.
+    const filtered = 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 (dep === "frontend-plan-revision-pi") {
+                if (byId.has("frontend-plan-pi"))
+                    next.push("frontend-plan-pi");
+                continue;
+            }
+            if (dep === "frontend-first-design-gate-shell" ||
+                dep === "frontend-design-gate-pi") {
+                // skip removed gates
+                continue;
+            }
+            if (byId.has(dep) || dep === "frontend-implement-pi")
+                next.push(dep);
+        }
+        return [...new Set(next)];
+    };
+    return filtered.map((task) => {
+        const depends_on = remap(task.depends_on);
+        // Ensure final design review still has plan + mock + contract path
+        if (task.id === "frontend-final-design-review-pi") {
+            for (const need of [
+                "frontend-plan-pi",
+                "frontend-mock-assess-pi",
+                "frontend-implementation-contract-shell",
+            ]) {
+                if (byId.has(need) && !depends_on.includes(need))
+                    depends_on.push(need);
+            }
+        }
+        if (task.id === "frontend-requirement-coverage-shell") {
+            const shell = task.shell?.requirementCoverageGate
+                ? {
+                    ...task.shell,
+                    requirementCoverageGate: {
+                        ...task.shell.requirementCoverageGate,
+                        fromNodeIds: task.shell.requirementCoverageGate.fromNodeIds.map((nodeId) => nodeId === "frontend-plan-revision-pi"
+                            ? "frontend-plan-pi"
+                            : nodeId),
+                    },
+                }
+                : task.shell;
+            return { ...task, depends_on, shell };
+        }
+        if (task.id === "frontend-implementation-contract-shell") {
+            const nextDeps = depends_on.filter((dep) => dep !== "frontend-plan-revision-pi");
+            if (!nextDeps.includes("frontend-plan-pi") &&
+                byId.has("frontend-plan-pi")) {
+                nextDeps.push("frontend-plan-pi");
+            }
+            const shell = task.shell
+                ? {
+                    ...task.shell,
+                    jsonArtifactGate: task.shell.jsonArtifactGate
+                        ? {
+                            ...task.shell.jsonArtifactGate,
+                            fromNodeId: "frontend-plan-pi",
+                        }
+                        : task.shell.jsonArtifactGate,
+                }
+                : task.shell;
+            return { ...task, depends_on: nextDeps, shell };
+        }
+        if (task.id === "frontend-implement-pi") {
+            // still requires final design gate
+            for (const need of [
+                "frontend-final-design-gate-shell",
+                "frontend-implementation-contract-shell",
+            ]) {
+                if (byId.has(need) && !depends_on.includes(need))
+                    depends_on.push(need);
+            }
+        }
+        return { ...task, depends_on };
+    });
+}
 function buildFrontendHybridDagFromTask(sources) {
     const { taskConfig } = sources;
     const mockCapability = sources.frontendMockCapability ?? {
         status: "absent",
         evidencePaths: [],
         verifyCommands: [],
-        reasons: ["Frontend Mock capability was not precomputed; assessment must verify repository evidence."],
+        reasons: [
+            "Frontend Mock capability was not precomputed; assessment must verify repository evidence.",
+        ],
     };
     const mockMode = sources.frontendMockMode ??
         resolveFrontendMockMode(mockCapability, taskConfig, hasApiDependency(sources));
@@ -1523,8 +1707,22 @@ function buildFrontendHybridDagFromTask(sources) {
     const forbiddenPaths = mergeForbiddenPaths(taskConfig);
     const implementPaths = resolveImplementPaths(taskConfig);
     const implementId = frontendImplementationNodeId();
-    const sourceContext = buildSourceContextBlock(sources);
     const mockContextBlock = resolveFrontendMockContextBlock(frontendSources);
+    const capabilityContextBlock = resolveFrontendCapabilityContextBlock(frontendSources);
+    const frontendRisk = frontendSources.frontendRisk ??
+        classifyFrontendRisk({
+            title: taskConfig.title,
+            requirementMarkdown: sources.requirementMarkdown,
+            constraintMarkdown: sources.constraintMarkdown ?? undefined,
+            allowedPaths: taskConfig.allowedPaths,
+            complexity: taskConfig.complexity,
+        });
+    const sourceContext = [
+        buildSourceContextBlock(sources),
+        capabilityContextBlock,
+    ]
+        .filter(Boolean)
+        .join("\n\n");
     const hasMockVerifyCommands = (taskConfig.frontendMock?.verifyCommands.length ?? 0) > 0 ||
         mockCapability.verifyCommands.length > 0;
     const requirementIds = buildDagSourceBinding(sources).requirementIds;
@@ -1549,6 +1747,10 @@ function buildFrontendHybridDagFromTask(sources) {
         "Mock-backed behavior evidence proves only the documented frontend contract, never real API integration.",
         "frontend-implementation DAGs must complete deterministic static verification and behavior verification before final review.",
         "frontend review must block closeout unless review verdict is exactly VERDICT: pass.",
+        `Frontend risk classification: ${frontendRisk.selectedRisk} — ${frontendRisk.reason}`,
+        frontendRisk.forceFullGates
+            ? "High-risk or supervised: keep full design gates; do not weaken write boundaries."
+            : "Risk-aware topology may omit redundant design revision nodes for small tasks only.",
     ];
     // Guard: blocked mode — generate assessment-only DAG with no writer reachable
     if (mockMode === "blocked") {
@@ -1671,11 +1873,12 @@ function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown implementation plan with Requirement Coverage, Implementation Steps, Target Files, UI State Handling, Styling / Component Strategy, Interaction Notes, Mock / API Strategy, Dependency Policy, Verification Plan, Real Integration Gap, and Residual Risks. No file writes.",
+                outputContract: "Markdown implementation plan with Requirement Coverage, Implementation Steps, Target Files, UI State Handling, Styling / Component Strategy, Interaction Notes, Mock / API Strategy, Dependency Policy, Verification Plan, Real Integration Gap, and Residual Risks, followed by exactly one fenced json object conforming to frontend-implementation-contract-v1 when this node is the effective plan source. No file writes.",
                 subtask_prompt: [
                     "Based on frontend-contract-pi, frontend-scout-pi, and the gated frontend-mock-assess-pi strategy, return a minimal frontend implementation plan.",
                     "Carry the selected Mock / API strategy, endpoint/fixture mapping, explicit activation, production-default-off rule, verification commands, and Real Integration Gap into the plan.",
                     "Include ordered steps, target files, UI state handling, styling/component strategy, interaction notes, Mock/API strategy, dependency policy, deterministic verification entrypoints, and residual risks. Use only the fixed entrypoints below; implementation may add tests behind them but cannot replace them.",
+                    "End with exactly one fenced json object conforming to frontend-implementation-contract-v1 so small topology can materialize the contract without plan-revision.",
                     requirementCoverageInstruction,
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
                     fixedVerificationContext,
@@ -1742,7 +1945,7 @@ function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown revision plan (pass case: first line PASS_NO_REVISION_NEEDED with Requirement Coverage confirmation; request-revision case: complete revised implementation plan with corrections from design findings and Requirement Coverage). No file writes.",
+                outputContract: "Markdown revision plan followed by exactly one fenced json object conforming to frontend-implementation-contract-v1. The JSON is the authoritative materialization input. No file writes.",
                 subtask_prompt: [
                     "Consume frontend-plan-pi (original plan) and frontend-design-gate-pi (first design review findings).",
                     "If the first design gate passed (VERDICT: pass from frontend-design-gate-pi), output exactly:",
@@ -1755,27 +1958,59 @@ function buildFrontendHybridDagFromTask(sources) {
                     requirementCoverageInstruction,
                     "Do not turn MOCK_STRATEGY: blocked into an implementable strategy without new repository or contract evidence that resolves every blocker.",
                     "Read-only: do not modify code, docs, artifacts, or repository files. This node revises the plan only.",
+                    "End the response with exactly one fenced json object conforming to frontend-implementation-contract-v1. Bind it to the supplied task sources; map every requirement and applicable UI state to concrete implementation and verification targets or an explicit blocking evidence gap. Do not include secrets or unsafe paths.",
                     sourceContext,
                 ].join("\n\n"),
             },
-            ...(requirementIds.length > 0 ? [{
-                    id: "frontend-requirement-coverage-shell",
-                    depends_on: ["frontend-plan-revision-pi"],
-                    role: "verifier",
-                    executor: "shell",
-                    complexity: "LOW",
-                    writePolicy: "read-only",
-                    allowedPaths: readOnlyPaths,
-                    forbiddenPaths,
-                    outputContract: "Deterministic current-run evidence that the original or revised frontend plan retains every explicit REQ-/BR-/AC- identifier from the bound task sources.",
-                    subtask_prompt: "Block final design review when the current run's plan facts omit any explicit requirement identifier from the authoritative task sources.",
-                    shell: {
-                        commands: [],
-                        requirementCoverageGate: { fromNodeIds: ["frontend-plan-revision-pi"], requiredIds: requirementIds, label: "frontend requirement coverage" },
-                        cwd: ".",
-                        timeoutMs: 60000,
+            ...(requirementIds.length > 0
+                ? [
+                    {
+                        id: "frontend-requirement-coverage-shell",
+                        depends_on: ["frontend-plan-revision-pi"],
+                        role: "verifier",
+                        executor: "shell",
+                        complexity: "LOW",
+                        writePolicy: "read-only",
+                        allowedPaths: readOnlyPaths,
+                        forbiddenPaths,
+                        outputContract: "Deterministic current-run evidence that the original or revised frontend plan retains every explicit REQ-/BR-/AC- identifier from the bound task sources.",
+                        subtask_prompt: "Block final design review when the current run's plan facts omit any explicit requirement identifier from the authoritative task sources.",
+                        shell: {
+                            commands: [],
+                            requirementCoverageGate: {
+                                fromNodeIds: ["frontend-plan-revision-pi"],
+                                requiredIds: requirementIds,
+                                label: "frontend requirement coverage",
+                            },
+                            cwd: ".",
+                            timeoutMs: 60000,
+                        },
                     },
-                }] : []),
+                ]
+                : []),
+            {
+                id: "frontend-implementation-contract-shell",
+                depends_on: ["frontend-plan-revision-pi"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Run-owned validated frontend-implementation-contract-v1 artifact path, schema id, and SHA-256.",
+                subtask_prompt: "Materialize the effective frontend plan as a source-bound structured contract; fail closed on missing or invalid output.",
+                shell: {
+                    commands: [],
+                    jsonArtifactGate: {
+                        fromNodeId: "frontend-plan-revision-pi",
+                        schemaId: "frontend-implementation-contract-v1",
+                        artifactName: "frontend-implementation-contract.json",
+                        outputDir: "contracts",
+                    },
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            },
             {
                 id: "frontend-final-design-review-pi",
                 depends_on: [
@@ -1783,7 +2018,10 @@ function buildFrontendHybridDagFromTask(sources) {
                     "frontend-plan-pi",
                     "frontend-design-gate-pi",
                     "frontend-mock-assess-pi",
-                    ...(requirementIds.length > 0 ? ["frontend-requirement-coverage-shell"] : []),
+                    "frontend-implementation-contract-shell",
+                    ...(requirementIds.length > 0
+                        ? ["frontend-requirement-coverage-shell"]
+                        : []),
                 ],
                 role: "reviewer",
                 executor: "pi",
@@ -1833,6 +2071,7 @@ function buildFrontendHybridDagFromTask(sources) {
                 id: implementId,
                 depends_on: [
                     "frontend-final-design-gate-shell",
+                    "frontend-implementation-contract-shell",
                     "frontend-plan-revision-pi",
                     "frontend-final-design-review-pi",
                     "frontend-plan-pi",
@@ -1847,22 +2086,28 @@ function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: implementPaths.allowedPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown summary with Changed Files, Implemented Behavior, UI States Covered, Styling / Component Notes, Verification Attempted, and Residual Risks.",
+                outputContract: "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.",
                 subtask_prompt: [
-                    "Implement the final approved frontend plan (from frontend-plan-revision-pi) with minimal focused changes.",
-                    "Implement only the approved Mock strategy from frontend-mock-assess-pi as carried through the approved plan. 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.",
+                    "Implement against the validated run-owned Frontend Implementation Contract from frontend-implementation-contract-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
+                    "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 and applicable UI state from the contract to concrete files. Do not invent shell verification commands; only frozen static/behavior entrypoints will run.",
+                    "Implement only the approved Mock strategy from frontend-mock-assess-pi as carried in the 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.",
                     "The frontend-final-design-review-pi verdict confirmed the plan is ready. 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 write root artifacts/** unless explicitly included in writeSet. Do not claim Browser/visual verification.",
                     writerDeliveryContract(taskConfig),
                     sourceContext,
                     mockContextBlock,
-                ].filter((value) => Boolean(value)).join("\n\n"),
+                ]
+                    .filter((value) => Boolean(value))
+                    .join("\n\n"),
             },
             // Optional dedicated Mock verification exists only when trusted commands
             // were frozen at generation time. Behavior verification remains required.
             ...(mockMode === "required" && hasMockVerifyCommands
-                ? [buildFrontendMockVerifyNode(frontendSources, implementId, readOnlyPaths, forbiddenPaths)]
+                ? [
+                    buildFrontendMockVerifyNode(frontendSources, implementId, readOnlyPaths, forbiddenPaths),
+                ]
                 : []),
             {
                 id: "frontend-static-verify-shell",
@@ -1882,6 +2127,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     verifyEvidence: staticVerifyEvidence,
                     cwd: ".",
                     timeoutMs: 300000,
+                    nonZeroExitPolicy: "record",
                 },
             },
             {
@@ -1900,14 +2146,166 @@ function buildFrontendHybridDagFromTask(sources) {
                     verifyEvidence: behaviorVerifyEvidence,
                     cwd: ".",
                     timeoutMs: 300000,
+                    nonZeroExitPolicy: "record",
                 },
             },
             {
-                id: "frontend-review-pi",
+                id: "frontend-verification-trace-shell",
                 depends_on: [
+                    "frontend-behavior-verify-shell",
                     "frontend-static-verify-shell",
+                    "frontend-implementation-contract-shell",
+                ],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Deterministic verification trace: contract verificationTargets bound to current-run static/behavior commandLabels; target files/symbols exist; Browser/visual not-run. No worktree writes.",
+                subtask_prompt: "Validate AC/UI/verification targets against frozen shell evidence and workspace files. Do not invent commands. Does not prove semantic test quality.",
+                shell: {
+                    commands: ["frontend-verification-trace-gate"],
+                    cwd: ".",
+                    timeoutMs: 120000,
+                    nonZeroExitPolicy: "record",
+                },
+            },
+            {
+                id: "frontend-failure-assess-shell",
+                depends_on: [
+                    "frontend-verification-trace-shell",
                     "frontend-behavior-verify-shell",
+                    "frontend-static-verify-shell",
+                    "frontend-implementation-contract-shell",
+                ],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Run-owned frontend-repair-assessment-v1 at contracts/frontend-repair-assessment.json classifying verify/trace failures as repairable or not.",
+                subtask_prompt: "Assess current-run static/behavior/trace failure facts against the validated contract. Do not repair code.",
+                shell: {
+                    commands: ["frontend-failure-assess-gate"],
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            },
+            {
+                id: "frontend-repair-contract-shell",
+                depends_on: ["frontend-failure-assess-shell"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Deterministic repair eligibility gate: pass when no failure or repairable assessment; fail-closed on non-repairable classes.",
+                subtask_prompt: "Validate frontend-repair-assessment writeSet subset, attempt limit, and eligibility before repair writer.",
+                shell: {
+                    commands: ["frontend-repair-contract-gate"],
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            },
+            {
+                id: "frontend-repair-pi",
+                depends_on: [
+                    "frontend-repair-contract-shell",
+                    "frontend-failure-assess-shell",
                     implementId,
+                ],
+                role: "implementer",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: resolveWriterComplexity(taskConfig),
+                writePolicy: "exclusive",
+                writeSet: implementPaths.writeSet,
+                allowedPaths: implementPaths.allowedPaths,
+                forbiddenPaths,
+                skills: FRONTEND_IMPLEMENTATION_SKILLS,
+                outputContract: "Repair summary or explicit no-op when assessment has no failure/eligible=false path already gated. 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.",
+                    "If failedNodeIds is empty, return no-op with evidence. If eligible repairable failure, apply the smallest fix inside the original implement writeSet only.",
+                    "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.",
+                    writerDeliveryContract(taskConfig),
+                    sourceContext,
+                    mockContextBlock,
+                ]
+                    .filter((value) => Boolean(value))
+                    .join("\n\n"),
+            },
+            {
+                id: "frontend-static-reverify-shell",
+                depends_on: ["frontend-repair-pi"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Archived static re-verification after repair using the same frozen commands; fail on nonzero.",
+                subtask_prompt: "Re-run frozen static entrypoints after repair. Fresh evidence only; do not rewrite prior failure artifacts.",
+                shell: {
+                    commands: staticShellCommands,
+                    verifyEvidence: staticVerifyEvidence,
+                    cwd: ".",
+                    timeoutMs: 300000,
+                },
+            },
+            {
+                id: "frontend-behavior-reverify-shell",
+                depends_on: ["frontend-static-reverify-shell"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: behaviorPaths,
+                forbiddenPaths,
+                outputContract: "Archived behavior re-verification after repair using the same frozen commands; fail on nonzero.",
+                subtask_prompt: "Re-run frozen behavior entrypoints after repair.",
+                shell: {
+                    commands: behaviorShellCommands,
+                    verifyEvidence: behaviorVerifyEvidence,
+                    cwd: ".",
+                    timeoutMs: 300000,
+                },
+            },
+            {
+                id: "frontend-verification-retrace-shell",
+                depends_on: [
+                    "frontend-behavior-reverify-shell",
+                    "frontend-static-reverify-shell",
+                    "frontend-implementation-contract-shell",
+                ],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Re-run verification trace against contract and reverify shell evidence after repair.",
+                subtask_prompt: "Trace AC/UI/verification targets against post-repair static/behavior evidence.",
+                shell: {
+                    commands: ["frontend-verification-trace-gate"],
+                    cwd: ".",
+                    timeoutMs: 120000,
+                },
+            },
+            {
+                id: "frontend-review-pi",
+                depends_on: [
+                    "frontend-verification-retrace-shell",
+                    "frontend-static-reverify-shell",
+                    "frontend-behavior-reverify-shell",
+                    "frontend-repair-pi",
+                    "frontend-failure-assess-shell",
+                    implementId,
+                    "frontend-implementation-contract-shell",
                     "frontend-contract-pi",
                     "frontend-plan-pi",
                     "frontend-plan-revision-pi",
@@ -1929,6 +2327,8 @@ function buildFrontendHybridDagFromTask(sources) {
                     "Review the frontend implementation and verification evidence.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
                     "Any Critical or Important finding must force VERDICT: request-revision.",
+                    "Read the validated frontend-implementation-contract, frontend-verification-trace evidence, static/behavior shell facts, and actual diff. Trace proves command/file/symbol binding only—not semantic correctness.",
+                    "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).",
                     "Use the direct contract, original plan, revision/no-op result, and final design review to reconstruct the approved plan and design verdict; do not infer them from the implementation summary.",
                     "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 or no-remote behavior evidence. Verify that the real request remains the default when Mock activation is absent.",
                     "Inspect the production/default-real-path static evidence directly and require Mock activation to be off for that check.",
@@ -1966,8 +2366,12 @@ function buildFrontendHybridDagFromTask(sources) {
                 depends_on: [
                     "frontend-review-gate-shell",
                     "frontend-review-pi",
-                    "frontend-static-verify-shell",
-                    "frontend-behavior-verify-shell",
+                    "frontend-verification-retrace-shell",
+                    "frontend-static-reverify-shell",
+                    "frontend-behavior-reverify-shell",
+                    "frontend-repair-pi",
+                    "frontend-failure-assess-shell",
+                    "frontend-implementation-contract-shell",
                     "frontend-mock-assess-pi",
                     ...(mockMode === "required" && hasMockVerifyCommands
                         ? ["frontend-mock-verify-shell"]
@@ -1985,6 +2389,7 @@ function buildFrontendHybridDagFromTask(sources) {
                 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.",
+                    "Include a coverage matrix for each requirement id, applicable UI state, and verification target/check with status passed|failed|not-run|blocked|unavailable. Always state Browser accessibility verification: not-run and Visual regression: not-run. Use frontend-verification-trace 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.`,
                     "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
                     sourceContext,
@@ -1993,6 +2398,7 @@ function buildFrontendHybridDagFromTask(sources) {
             },
         ],
     };
+    spec.tasks = pruneFrontendTasksForRisk(spec.tasks, frontendRisk);
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
@@ -2049,10 +2455,64 @@ function buildBackendTestAnalysisContractGateNode(sources) {
         },
     };
 }
+function buildBackendTestEnvironmentScoutNode(sources) {
+    return {
+        id: "backend-test-environment-scout-pi",
+        depends_on: ["backend-test-analysis-contract-shell"],
+        role: "scout",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pure Backend Test Execution Contract v1 JSON object matching docs/templates/backend-test-execution.schema.json. No Markdown prose and no file writes.",
+        subtask_prompt: [
+            "Read-only environment scout for backend-test pytest MVP.",
+            "Return exactly one JSON object matching Backend Test Execution Contract v1 (schema docs/templates/backend-test-execution.schema.json).",
+            "Prefer pure JSON; a single fenced json block is tolerated; no trailing prose.",
+            "Discover only non-secret evidence: pytest config files (pytest.ini / pyproject.toml / setup.cfg test paths), candidate test roots, existing fixtures/clients, documented run commands, and env *names* (not values).",
+            "Do NOT search the whole repo for secrets, .env values, tokens, private keys, or production credentials.",
+            'framework must be "pytest". Default targetMode to "in-process" unless evidence clearly shows an external service base URL env name or documented managed start/stop with sourceRef.',
+            'Do NOT select targetMode "managed-command" unless task source documents a safe start/stop command with an explicit sourceRef; otherwise leave managedCommand absent and record the gap in evidenceGaps.',
+            "testRoot and workingDirectory must be repo-relative posix paths without .. or absolute form. Adapter default testRoot is testcase when evidence is incomplete.",
+            "runner must not include secret values. report.format must be junit with a relativeHint under the run (e.g. reports/backend-test-junit.xml).",
+            "requiredEnvNames lists env NAMES only. baseUrlEnvName is required only for external-running-service and must match ^[A-Z_][A-Z0-9_]*$.",
+            "Record incomplete discovery in evidenceGaps. Populate evidenceRefs with repo-relative paths actually read.",
+            "Required top-level keys: schemaVersion, framework, runner, testRoot, workingDirectory, report, targetMode, existingFixtures, authenticationMode, requiredEnvNames, dataIsolation, evidenceGaps, evidenceRefs.",
+            "Read-only: do not modify code, docs, artifacts, or repository files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildBackendTestExecutionContractGateNode(sources) {
+    return {
+        id: "backend-test-execution-contract-shell",
+        depends_on: ["backend-test-environment-scout-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validated run-owned Backend Test Execution Contract v1 artifact pointer, schema ID, and SHA-256.",
+        subtask_prompt: "Materialize and validate the backend-test execution contract under the current DAG run.",
+        shell: {
+            commands: [],
+            jsonArtifactGate: {
+                fromNodeId: "backend-test-environment-scout-pi",
+                schemaId: "backend-test-execution-v1",
+                artifactName: "backend-test-execution.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
 function buildGenerateBackendFunctionalCasesNode(sources) {
     return {
         id: "generate-backend-functional-cases-pi",
-        depends_on: ["backend-test-analysis-contract-shell"],
+        depends_on: ["backend-test-execution-contract-shell"],
         role: "implementer",
         executor: "pi",
         toolProfile: "write",
@@ -2064,7 +2524,8 @@ function buildGenerateBackendFunctionalCasesNode(sources) {
         // 注意：Pi 节点超时由 executor 层控制（默认 30 分钟）
         // 如需调整，在 harness.json 的 executors.pi 中配置 modelConfig.timeoutMs
         subtask_prompt: [
-            "Read the validated structured artifact pointer from backend-test-analysis-contract-shell and generate cases only from that JSON contract.", ,
+            "Read the validated structured artifact pointer from backend-test-analysis-contract-shell and generate cases only from that JSON contract.",
+            ,
             "",
             "## Output Steps (do in order):",
             "1. First, output a brief summary: how many modules, how many cases planned per module",
@@ -2090,15 +2551,92 @@ function buildGenerateBackendFunctionalCasesNode(sources) {
             "",
             "## Constraints:",
             "- Stay within writeSet: testcase/md/**",
-            "- Do NOT re-read source documents or fall back to free-form analysis — use the validated structured artifact only", ,
+            "- Do NOT re-read source documents or fall back to free-form analysis — use the validated structured artifact only",
+            ,
             "- Do not write root artifacts/**",
         ].join("\n\n"),
     };
 }
+function buildEmitBackendCaseManifestNode(sources) {
+    return {
+        id: "emit-backend-case-manifest-pi",
+        depends_on: [
+            "generate-backend-functional-cases-pi",
+            "backend-test-analysis-contract-shell",
+        ],
+        role: "scout",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pure Backend Test Case Manifest v1 JSON (schema docs/templates/backend-test-case-manifest.schema.json). No file writes; model must not write .harness/**.",
+        subtask_prompt: [
+            "Emit Backend Test Case Manifest v1 as pure JSON (or one fenced json block with no trailing text).",
+            "Read-only: use validated contracts/backend-test-analysis.json pointer + testcase/md/** only. Do not write repository files or .harness/**.",
+            "sourceBinding must match the analysis contract / DAG source binding exactly (taskId, requirementPath, requirementSha256, referencePaths, requirementIds).",
+            "For each functional case under testcase/md/: caseId BE-<MODULE>-<NNN>, acIds[], title, category, automationStatus.",
+            "After case generation (pre-pytest), default automationStatus=planned. Use skipped/unsupported only with gapReason. Use generated only when file+symbol already exist.",
+            "evidenceGaps: structured gaps for explicit AC-* that cannot be mapped to a case.",
+            "Do NOT invent coverage percentages. Optional coverageSummary must match deterministic counts (gate recomputes/validates).",
+            "No secrets or credential-shaped fields.",
+        ].join("\n\n"),
+    };
+}
+function buildBackendTestCaseManifestGateNode(sources) {
+    return {
+        id: "backend-test-case-manifest-shell",
+        depends_on: ["emit-backend-case-manifest-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validated run-owned Backend Test Case Manifest v1 at contracts/backend-test-case-manifest.json (schemaId backend-test-case-manifest-v1) with deterministic AC coverage.",
+        subtask_prompt: "Materialize and validate Backend Test Case Manifest v1; fail closed on duplicate IDs, unknown AC, missing AC coverage without gap, or skipped without gapReason.",
+        shell: {
+            commands: [],
+            jsonArtifactGate: {
+                fromNodeId: "emit-backend-case-manifest-pi",
+                schemaId: "backend-test-case-manifest-v1",
+                artifactName: "backend-test-case-manifest.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildBackendTestTraceabilityGateNode(sources) {
+    return {
+        id: "backend-test-traceability-gate-shell",
+        depends_on: [
+            "generate-backend-pytest-pi",
+            "backend-test-case-manifest-shell",
+        ],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic traceability: generated cases have real file/symbol; skipped/unsupported have gapReason; convention symbols scanned under testcase/**/test_*.py.",
+        subtask_prompt: "Fail closed when generated automation claims do not resolve to workspace pytest symbols, or skip/unsupported lacks gapReason.",
+        shell: {
+            commands: ["backend-test-traceability-gate"],
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
 function buildReviewBackendCasesNode(sources) {
     return {
         id: "review-backend-cases-pi",
-        depends_on: ["generate-backend-functional-cases-pi", "backend-test-analysis-contract-shell"],
+        depends_on: [
+            "backend-test-case-manifest-shell",
+            "backend-test-analysis-contract-shell",
+        ],
         role: "reviewer",
         executor: "pi",
         complexity: "HIGH",
@@ -2107,7 +2645,7 @@ function buildReviewBackendCasesNode(sources) {
         forbiddenPaths: commonForbiddenPaths(sources),
         outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision; followed by Findings and Coverage Assessment. No file writes.",
         subtask_prompt: [
-            "Review the generated backend functional test cases under testcase/md/.",
+            "Review the generated backend functional test cases under testcase/md/ and the validated Case Manifest v1.",
             "",
             "## Mandatory First Line:",
             "First non-empty line must be exactly: VERDICT: pass or VERDICT: request-revision",
@@ -2116,9 +2654,10 @@ function buildReviewBackendCasesNode(sources) {
             "- ID format: every case uses BE-<MODULE>-<NNN>",
             "- Positive coverage: each acceptance criterion (AC-xxx) has happy-path case",
             "- Negative coverage: error scenarios (invalid input, not found, state violations)",
-            "- Traceability: each AC maps to at least one case ID",
+            "- Traceability: each AC maps to at least one case ID (prefer contracts/backend-test-case-manifest.json coverageSummary)",
             "- Case structure: ID, Title, Precondition, Steps, Expected Result",
             "- No duplicate IDs across files",
+            "- Manifest consistency: MD cases align with manifest caseId/acIds; do not invent coverage %",
             "",
             "## Conditional Coverage (check ONLY if mentioned in upstream analysis):",
             "- Boundary coverage: check ONLY if analyze-inputs-pi mentions value ranges, length limits, numeric bounds, or format constraints",
@@ -2133,13 +2672,13 @@ function buildReviewBackendCasesNode(sources) {
             "- Any Critical fails OR Important > 2 → VERDICT: request-revision",
             "",
             "## Output After Verdict:",
-            "1. Coverage Assessment table (AC → case IDs)",
+            "1. Coverage Assessment table (AC → case IDs) using manifest + MD",
             "2. Findings list (Critical/Important/Informational)",
             "3. Statistics (total cases, positive/negative/boundary breakdown)",
             "",
             "## Constraints:",
             "- Read-only: do not modify files",
-            "- Read the validated backend-test analysis artifact pointer from upstream and use it for AC/source-binding coverage checks", ,
+            "- Read validated analysis + case manifest artifacts; do not recompute coverage percentages",
             "- Use testcase/md/ files for case review",
         ].join("\n\n"),
     };
@@ -2172,7 +2711,10 @@ function buildReviewBackendCasesGateNode(sources) {
 function buildGenerateBackendPytestNode(sources) {
     return {
         id: "generate-backend-pytest-pi",
-        depends_on: ["review-backend-cases-gate-shell"],
+        depends_on: [
+            "review-backend-cases-gate-shell",
+            "backend-test-execution-contract-shell",
+        ],
         role: "implementer",
         executor: "pi",
         toolProfile: "write",
@@ -2193,6 +2735,12 @@ function buildGenerateBackendPytestNode(sources) {
         subtask_prompt: [
             "Convert the reviewed test cases under testcase/md/ into pytest automation code.",
             "",
+            "## Inputs (MUST use validated contracts):",
+            "- Reviewed cases under testcase/md/ (after review-backend-cases-gate-shell).",
+            "- Validated Backend Test Analysis v1 under the current run contracts/ (analysis gate).",
+            "- Validated Backend Test Execution Contract v1 under contracts/backend-test-execution.json (execution gate).",
+            "Use only fixture names, env NAMES, testRoot, targetMode, and field/API facts already present in those contracts or reviewed cases. Do not invent production credentials or secret values.",
+            "",
             "## Output Steps (do in order):",
             "1. First, output a brief summary: how many files, how many test functions planned",
             "2. Then write each test file under testcase/",
@@ -2262,8 +2810,8 @@ function buildGenerateBackendPytestNode(sources) {
             "",
             "### Field Name Resolution",
             "Field names MUST come from the upstream analyze-inputs-pi output (API Endpoints section) or reviewed cases, NOT guessed. For example:",
-            "- If API spec defines {\"ret\": 0, \"msg\": \"success\"}, assert response.json()['ret'] and response.json()['msg']",
-            "- If API spec defines {\"code\": 4001, \"message\": \"error\"}, assert response.json()['code'] and response.json()['message']",
+            '- If API spec defines {"ret": 0, "msg": "success"}, assert response.json()[\'ret\'] and response.json()[\'msg\']',
+            '- If API spec defines {"code": 4001, "message": "error"}, assert response.json()[\'code\'] and response.json()[\'message\']',
             "",
             "## Conditional Implementation (include ONLY if test cases exist):",
             "- Authentication tests: implement ONLY if testcase/md/ contains auth-related cases",
@@ -2284,26 +2832,41 @@ function buildGenerateBackendPytestNode(sources) {
 function buildExecuteBackendPytestNode(sources) {
     // Keep the target worktree read-only: JUnit is runner-owned evidence under
     // the current DAG run and moves with active → completed/paused lifecycle.
+    // Adapter default testRoot is frozen at DAG generation time (auditable) and
+    // cross-checked against the materialized execution contract in preflight.
+    const frozenTestRoot = BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT;
+    const preflightCommand = buildBackendTestExecutionPreflightShellSnippet({
+        expectedTestRoot: frozenTestRoot,
+    });
+    // Map pytest exit 0/1 → node success ONLY when JUnit exists (assertion-fail is a
+    // legal result). Do not change global shell ok semantics. Persist raw exit for parse.
     const pytestCommand = [
-        'test -n "${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for backend pytest report" >&2; exit 2; }',
+        preflightCommand,
         'REPORT="${HARNESS_DAG_RUN_DIR}/reports/backend-test-junit.xml"',
+        'EXIT_FILE="${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
         'mkdir -p "$(dirname "${REPORT}")"',
-        'PYTHONDONTWRITEBYTECODE=1 python -m pytest testcase/ -v -p no:cacheprovider --junitxml="${REPORT}"',
-        'STATUS=$?',
+        `PYTHONDONTWRITEBYTECODE=1 python -m pytest ${frozenTestRoot}/ -v -p no:cacheprovider --junitxml="\${REPORT}"`,
+        "STATUS=$?",
+        'printf "%s" "${STATUS}" > "${EXIT_FILE}"',
         'printf "JUnit report: %s\\n" "${REPORT}"',
+        'printf "pytestExitCode=%s\\n" "${STATUS}"',
+        'if { [ "${STATUS}" -eq 0 ] || [ "${STATUS}" -eq 1 ]; } && [ -s "${REPORT}" ]; then exit 0; fi',
         'exit "${STATUS}"',
     ].join("; ");
     return {
         id: "execute-backend-pytest-shell",
-        depends_on: ["generate-backend-pytest-pi"],
+        depends_on: [
+            "backend-test-traceability-gate-shell",
+            "backend-test-execution-contract-shell",
+        ],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Archived pytest stdout/stderr with exit codes; JUnit XML is runner-owned evidence at $HARNESS_DAG_RUN_DIR/reports/backend-test-junit.xml. Must not modify worktree files, testcase sources, production code, or assertions.",
-        subtask_prompt: "Run pytest for the backend test suite; write JUnit evidence only under the current HARNESS_DAG_RUN_DIR/reports/.",
+        outputContract: "Archived pytest stdout/stderr; raw pytestExitCode side-channel + JUnit at $HARNESS_DAG_RUN_DIR/reports/**. Exit 0/1 with non-empty JUnit finishes the node so parse/classify/retrospect can run; assertion failures remain recorded in exit file.",
+        subtask_prompt: "Run pytest for the backend test suite; write JUnit + pytestExitCode evidence only under the current HARNESS_DAG_RUN_DIR/reports/.",
         shell: {
             commands: [pytestCommand],
             verifyEvidence: buildVerifyEvidence({
@@ -2318,10 +2881,61 @@ function buildExecuteBackendPytestNode(sources) {
         },
     };
 }
+function buildParseBackendTestResultNode(sources) {
+    return {
+        id: "parse-backend-test-result-shell",
+        depends_on: ["execute-backend-pytest-shell"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validated run-owned Backend Test Result v1 at contracts/backend-test-result.json (schemaId backend-test-result-v1) with outcome/counts/failures from deterministic JUnit parse.",
+        subtask_prompt: "Materialize Backend Test Result v1 from JUnit + pytestExitCode under the current DAG run (fail-closed on missing/corrupt report).",
+        shell: {
+            commands: [],
+            jsonArtifactGate: {
+                fromNodeId: "execute-backend-pytest-shell",
+                schemaId: "backend-test-result-v1",
+                artifactName: "backend-test-result.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildClassifyBackendTestResultNode(sources) {
+    return {
+        id: "classify-backend-test-result-pi",
+        depends_on: ["parse-backend-test-result-shell"],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Pure JSON classification: category in {ProductBug,TestBug,EnvFailure,ContractMismatch,FlakyTest,Unknown}, evidence[], confidence (capped), notes. No file writes.",
+        subtask_prompt: [
+            "Read-only classifier for Backend Test Result v1.",
+            "Return exactly one JSON object (prefer pure JSON; single fenced json block tolerated; no trailing prose).",
+            "Read contracts/backend-test-result.json (run-owned Result v1). Do NOT invent pass rates from raw logs.",
+            "category must be one of: ProductBug, TestBug, EnvFailure, ContractMismatch, FlakyTest, Unknown.",
+            "Hard constraints:",
+            "- Single-run failure MUST NOT use FlakyTest (use Unknown, TestBug, or ProductBug).",
+            "- executionStatus/outcome collection-error, command-error, or report-error MUST NOT use ProductBug.",
+            "- Prefer EnvFailure/Unknown/TestBug for env, import, collection, and missing-report cases.",
+            "- confidence must respect deterministic caps (≤0.75 for assertion failures; ≤0.6 for env/collection).",
+            "Include evidence[] referencing result fields (outcome, failed, failures[].name, executionStatus).",
+            "Read-only: do not modify code, docs, artifacts, or repository files.",
+        ].join("\n\n"),
+    };
+}
 function buildTestRetrospectNode(sources) {
     return {
         id: "test-retrospect-pi",
-        depends_on: ["execute-backend-pytest-shell"],
+        depends_on: ["classify-backend-test-result-pi"],
         role: "closeout",
         executor: "pi",
         toolProfile: "write",
@@ -2331,23 +2945,29 @@ function buildTestRetrospectNode(sources) {
         allowedPaths: ["docs/test-reports/**"],
         forbiddenPaths: commonForbiddenPaths(sources),
         subtask_prompt: [
-            "Read upstream outputs (review report + pytest results) and generate a test retrospective report.",
+            "Read upstream Result v1 + Case Manifest coverageSummary + classification and generate a test retrospective report.",
             "",
             "## Output Steps (do in order):",
             "1. First, output the maturity rating on the first line: Rating: A/B/C/D",
             "2. Then write the full report under docs/test-reports/",
             "",
+            "## Stats authority (deterministic only):",
+            "- Pass rate, failed/error/skipped counts, and failure list MUST come from contracts/backend-test-result.json only.",
+            "- AC coverage ratio / case counts MUST come from contracts/backend-test-case-manifest.json coverageSummary (or gate-derived fields). Do NOT invent coverage %.",
+            "- Use classify-backend-test-result-pi JSON as interpretive evidence only.",
+            "- NEVER rewrite a failed result as passed. Outcome gate (not this report) is authoritative for task success.",
+            "",
             "## Report Structure:",
             "1. Maturity Rating with rationale",
-            "2. Test Coverage Summary (total cases, pass rate, failed case analysis)",
+            "2. Test Coverage Summary (manifest coverageSummary + Result v1 pass rate)",
             "3. Review Findings and resolution status",
-            "4. Failed Test Analysis (if any)",
+            "4. Failed Test Analysis (if any) + classification category",
             "5. Recommendations for improvement",
             "",
             "## Rating Criteria:",
-            "- A: 100% acceptance criteria covered + 100% pytest pass + no Critical findings",
-            "- B: ≥80% coverage + ≥90% pass + Low findings only",
-            "- C: ≥60% coverage + ≥70% pass + no Critical findings",
+            "- A: coverageSummary.acCoverageRatio=1 + 100% pytest pass + no Critical findings",
+            "- B: acCoverageRatio≥0.8 + ≥90% pass + Low findings only",
+            "- C: acCoverageRatio≥0.6 + ≥70% pass + no Critical findings",
             "- D: below C thresholds",
             "",
             "## Constraints:",
@@ -2357,6 +2977,33 @@ function buildTestRetrospectNode(sources) {
         ].join("\n\n"),
     };
 }
+function buildBackendTestOutcomeGateNode(sources) {
+    const gateCommand = buildBackendTestOutcomeGateShellSnippet();
+    return {
+        id: "backend-test-outcome-gate-shell",
+        depends_on: ["test-retrospect-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Shell exit 0 only when Result v1 outcome=passed with failed=0 and error=0; non-zero otherwise. Ignores retrospective Markdown.",
+        subtask_prompt: "Gate the backend-test DAG on run-owned Result v1 shell facts only (not retrospective prose).",
+        shell: {
+            commands: [gateCommand],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [gateCommand],
+                finalFullRequired: true,
+            }),
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
 const BACKEND_TEST_DEFAULTS = {
     ...HYBRID_DEFAULTS,
     writePolicy: "read-only",
@@ -2388,6 +3035,9 @@ function buildBackendTestHybridDag(sources) {
         "review-backend-cases-gate-shell must block pytest generation unless the review verdict is exactly VERDICT: pass.",
         "If a target test filename already exists under testcase/, add a numeric suffix (_01, _02, ...); never overwrite or append to existing files.",
         "execute-backend-pytest-shell must not modify test assertions or production code to make tests pass; test failures indicate potential implementation issues and must be reported honestly.",
+        "parse-backend-test-result-shell materializes Backend Test Result v1 from JUnit + pytestExitCode; classify/retrospect run on pass and assertion-fail; backend-test-outcome-gate-shell uses result.outcome only.",
+        "backend-test-case-manifest-shell validates schemaId backend-test-case-manifest-v1 and materializes contracts/backend-test-case-manifest.json; AC coverage is fail-closed and deterministic.",
+        "backend-test-traceability-gate-shell verifies generated file/symbol existence after pytest generation and before execute; models must not invent coverage percentages.",
     ];
     const spec = {
         version: 3,
@@ -2409,12 +3059,20 @@ function buildBackendTestHybridDag(sources) {
         tasks: [
             buildAnalyzeInputsNode(sources),
             buildBackendTestAnalysisContractGateNode(sources),
+            buildBackendTestEnvironmentScoutNode(sources),
+            buildBackendTestExecutionContractGateNode(sources),
             buildGenerateBackendFunctionalCasesNode(sources),
+            buildEmitBackendCaseManifestNode(sources),
+            buildBackendTestCaseManifestGateNode(sources),
             buildReviewBackendCasesNode(sources),
             buildReviewBackendCasesGateNode(sources),
             buildGenerateBackendPytestNode(sources),
+            buildBackendTestTraceabilityGateNode(sources),
             buildExecuteBackendPytestNode(sources),
+            buildParseBackendTestResultNode(sources),
+            buildClassifyBackendTestResultNode(sources),
             buildTestRetrospectNode(sources),
+            buildBackendTestOutcomeGateNode(sources),
         ],
     };
     applyDefaultReadOnlyRetryPolicy(spec);
@@ -2427,8 +3085,12 @@ function buildBackendTestHybridDag(sources) {
 // ---------------------------------------------------------------------------
 function buildFrontendTestHybridDag(sources) {
     const config = sources.taskConfig.frontendTest ?? { maxCasesPerBatch: 20 };
-    const hasFrontendTestWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "testcase/frontend/**" || pattern === "testcase/**" || pattern === "**");
-    const hasReportWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "docs/test-reports/**" || pattern === "docs/**" || pattern === "**");
+    const hasFrontendTestWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "testcase/frontend/**" ||
+        pattern === "testcase/**" ||
+        pattern === "**");
+    const hasReportWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "docs/test-reports/**" ||
+        pattern === "docs/**" ||
+        pattern === "**");
     if (!hasFrontendTestWriteScope || !hasReportWriteScope) {
         throw new Error('frontend-test requires task.json allowedPaths to include both "testcase/frontend/**" and "docs/test-reports/**" (or explicit containing globs).');
     }
@@ -2474,44 +3136,163 @@ function buildFrontendTestHybridDag(sources) {
             "Browser startup for generated cases must be playwright-cli open --browser=chrome --headed <base-url>.",
             "Token settings are post-case stop thresholds, never a hard provider token cap. Unstarted cases after a threshold are blocked: token-budget-exhausted.",
         ],
-        defaults: { ...HYBRID_DEFAULTS, writePolicy: "read-only", contextProfile: sources.taskConfig.contextProfile },
+        defaults: {
+            ...HYBRID_DEFAULTS,
+            writePolicy: "read-only",
+            contextProfile: sources.taskConfig.contextProfile,
+        },
         skillsByRole: {
-            planner: ["loop-agent"], scout: ["playwright-cli"], implementer: ["playwright-cli-case-generator", "playwright-cli", "webapp-testing"], reviewer: ["requesting-code-review"], verifier: ["playwright-cli", "webapp-testing"], closeout: ["loop-agent", "verification-before-completion"],
+            planner: ["loop-agent"],
+            scout: ["playwright-cli"],
+            implementer: [
+                "playwright-cli-case-generator",
+                "playwright-cli",
+                "webapp-testing",
+            ],
+            reviewer: ["requesting-code-review"],
+            verifier: ["playwright-cli", "webapp-testing"],
+            closeout: ["loop-agent", "verification-before-completion"],
         },
         executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
         tasks: [
             {
-                id: "retrieve-frontend-test-context-pi", depends_on: [], role: "planner", executor: "pi", toolProfile: "write", complexity: "HIGH", writePolicy: "exclusive", writeSet: ragWriteSet, allowedPaths: [...commonReadOnlyPaths(sources), ...ragWriteSet], forbiddenPaths: forbidden,
+                id: "retrieve-frontend-test-context-pi",
+                depends_on: [],
+                role: "planner",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: "HIGH",
+                writePolicy: "exclusive",
+                writeSet: ragWriteSet,
+                allowedPaths: [...commonReadOnlyPaths(sources), ...ragWriteSet],
+                forbiddenPaths: forbidden,
                 outputContract: "Write testcase/frontend/rag/context.md and coverage-map.md with traceable UI/API/test-environment facts.",
-                subtask_prompt: ["Build the frontend test RAG package.", "Read task source, relevant routes/components/API or Mock facts, existing tests, and execution contract. Write only testcase/frontend/rag/context.md and coverage-map.md.", "Record AC IDs, source paths, routes, states, roles, fixture/data prerequisites, API mapping status, risks, and isolated execution contract. Do not guess unavailable facts.", buildSourceContextBlock(sources)].join("\n\n"),
+                subtask_prompt: [
+                    "Build the frontend test RAG package.",
+                    "Read task source, relevant routes/components/API or Mock facts, existing tests, and execution contract. Write only testcase/frontend/rag/context.md and coverage-map.md.",
+                    "Record AC IDs, source paths, routes, states, roles, fixture/data prerequisites, API mapping status, risks, and isolated execution contract. Do not guess unavailable facts.",
+                    buildSourceContextBlock(sources),
+                ].join("\n\n"),
             },
             {
-                id: "generate-frontend-functional-cases-pi", depends_on: ["retrieve-frontend-test-context-pi"], role: "implementer", executor: "pi", toolProfile: "write", complexity: "HIGH", writePolicy: "exclusive", writeSet: casesWriteSet, allowedPaths: [...ragWriteSet, ...casesWriteSet], forbiddenPaths: forbidden,
+                id: "generate-frontend-functional-cases-pi",
+                depends_on: ["retrieve-frontend-test-context-pi"],
+                role: "implementer",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: "HIGH",
+                writePolicy: "exclusive",
+                writeSet: casesWriteSet,
+                allowedPaths: [...ragWriteSet, ...casesWriteSet],
+                forbiddenPaths: forbidden,
                 outputContract: "Write executable Markdown frontend cases, index.md, and manifest.json schemaVersion 1; no test source code.",
-                subtask_prompt: ["Use skill playwright-cli-case-generator.", "Read only testcase/frontend/rag/context.md, testcase/frontend/rag/coverage-map.md, and existing testcase/frontend/cases/. Write only testcase/frontend/cases/**.", "Generate Markdown cases, index.md and manifest.json (schemaVersion 1; cases[] with caseId, casePath, dimension, acIds, evidenceDir). IDs use FE-<FEATURE>-<NNN>-<dimension>; dimensions core|boundary|flow|backend.", "Never infer API fields, constraints, SLA, credentials, or unrecorded test data. Do not create pytest or Playwright source. Every browser start command is: playwright-cli open --browser=chrome --headed <base-url>.", "Each case must be independent, declare its session/preconditions/data cleanup, UI assertions, evidence paths under testcase/frontend/evidence/<case-id>/, and mark unsafe/missing dependencies blocked."].join("\n\n"),
+                subtask_prompt: [
+                    "Use skill playwright-cli-case-generator.",
+                    "Read only testcase/frontend/rag/context.md, testcase/frontend/rag/coverage-map.md, and existing testcase/frontend/cases/. Write only testcase/frontend/cases/**.",
+                    "Generate Markdown cases, index.md and manifest.json (schemaVersion 1; cases[] with caseId, casePath, dimension, acIds, evidenceDir). IDs use FE-<FEATURE>-<NNN>-<dimension>; dimensions core|boundary|flow|backend.",
+                    "Never infer API fields, constraints, SLA, credentials, or unrecorded test data. Do not create pytest or Playwright source. Every browser start command is: playwright-cli open --browser=chrome --headed <base-url>.",
+                    "Each case must be independent, declare its session/preconditions/data cleanup, UI assertions, evidence paths under testcase/frontend/evidence/<case-id>/, and mark unsafe/missing dependencies blocked.",
+                ].join("\n\n"),
             },
             {
-                id: "review-frontend-cases-pi", depends_on: ["generate-frontend-functional-cases-pi"], role: "reviewer", executor: "pi", complexity: "HIGH", writePolicy: "read-only", allowedPaths: [...ragWriteSet, ...casesWriteSet], forbiddenPaths: forbidden,
-                outputContract: "First line VERDICT: pass or VERDICT: request-revision, followed by AC-to-case coverage and execution risk findings; no writes.", subtask_prompt: "Review only the RAG package and frontend Markdown cases. Verify traceability, independent execution, safe data/environment handling, manifest correctness, and evidence requirements. The verdict is advisory and does not block case execution.",
+                id: "review-frontend-cases-pi",
+                depends_on: ["generate-frontend-functional-cases-pi"],
+                role: "reviewer",
+                executor: "pi",
+                complexity: "HIGH",
+                writePolicy: "read-only",
+                allowedPaths: [...ragWriteSet, ...casesWriteSet],
+                forbiddenPaths: forbidden,
+                outputContract: "First line VERDICT: pass or VERDICT: request-revision, followed by AC-to-case coverage and execution risk findings; no writes.",
+                subtask_prompt: "Review only the RAG package and frontend Markdown cases. Verify traceability, independent execution, safe data/environment handling, manifest correctness, and evidence requirements. The verdict is advisory and does not block case execution.",
             },
             {
-                id: "materialize-frontend-case-manifest-shell", depends_on: ["review-frontend-cases-pi"], role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: casesWriteSet, forbiddenPaths: forbidden,
-                outputContract: "stdout is exactly JSON { cases: [...] } after deterministic frontend manifest validation.", subtask_prompt: "Validate and materialize the generated frontend case manifest.", shell: { commands: [manifestValidation], cwd: ".", timeoutMs: 120000 },
+                id: "materialize-frontend-case-manifest-shell",
+                depends_on: ["review-frontend-cases-pi"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: casesWriteSet,
+                forbiddenPaths: forbidden,
+                outputContract: "stdout is exactly JSON { cases: [...] } after deterministic frontend manifest validation.",
+                subtask_prompt: "Validate and materialize the generated frontend case manifest.",
+                shell: { commands: [manifestValidation], cwd: ".", timeoutMs: 120000 },
             },
             {
-                id: "execute-frontend-cases-map", depends_on: ["materialize-frontend-case-manifest-shell"], role: "verifier", executor: "static", complexity: "LOW", writePolicy: "none", allowedPaths: [], forbiddenPaths: forbidden,
-                outputContract: "Serial aggregate of case execution summaries, evidence paths, tokens, and token-budget blocked cases.", subtask_prompt: "Expand and execute the validated frontend case manifest serially.", static: { resultMarkdown: "Frontend case map expansion barrier." },
-                dynamicExpansion: { type: "map_agent", workflowNodeId: "execute-frontend-cases-map", itemsFrom: "$.nodes['materialize-frontend-case-manifest-shell'].output.cases", itemName: "case", maxItems: config.maxCasesPerBatch, maxExpandedNodes: config.maxCasesPerBatch, childIdPrefix: "execute-frontend-case", tokenBudget: { maxTokensPerCase: config.maxTokensPerCase, maxTotalTokens: config.maxTotalTokens }, childTask: {
-                        executor: "pi", role: "verifier", skills: ["playwright-cli", "webapp-testing"], toolProfile: "write", complexity: "MED", writePolicy: "exclusive", allowedPaths: ["testcase/frontend/cases/{{case.caseId}}.md", "testcase/frontend/rag/context.md", "testcase/frontend/rag/coverage-map.md", `${evidenceRoot}/{{case.caseId}}/**`], forbiddenPaths: forbidden, writeSet: [`${evidenceRoot}/{{case.caseId}}/**`], outputContract: "Compact JSON <=1200 characters with case status, evidence paths, error summary, and tokens.", subtaskPromptTemplate: ["Execute exactly case {{case.caseId}} from {{case.casePath}} using playwright-cli and webapp-testing. This is a fresh Pi session; do not use /new.", "Use only the declared isolated test environment. If CLI/browser/base URL/credentials/fixture isolation is missing, record blocked rather than installing tools or guessing.", "Use playwright-cli open --browser=chrome --headed <base-url>. Persist execution.md, case-result.json, screenshots/trace/video/logs under {{case.evidenceDir}} before returning.", "A business failed or blocked case is a recorded result, not a node failure. Close the session and return only compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}."].join("\n\n")
-                    } },
+                id: "execute-frontend-cases-map",
+                depends_on: ["materialize-frontend-case-manifest-shell"],
+                role: "verifier",
+                executor: "static",
+                complexity: "LOW",
+                writePolicy: "none",
+                allowedPaths: [],
+                forbiddenPaths: forbidden,
+                outputContract: "Serial aggregate of case execution summaries, evidence paths, tokens, and token-budget blocked cases.",
+                subtask_prompt: "Expand and execute the validated frontend case manifest serially.",
+                static: { resultMarkdown: "Frontend case map expansion barrier." },
+                dynamicExpansion: {
+                    type: "map_agent",
+                    workflowNodeId: "execute-frontend-cases-map",
+                    itemsFrom: "$.nodes['materialize-frontend-case-manifest-shell'].output.cases",
+                    itemName: "case",
+                    maxItems: config.maxCasesPerBatch,
+                    maxExpandedNodes: config.maxCasesPerBatch,
+                    childIdPrefix: "execute-frontend-case",
+                    tokenBudget: {
+                        maxTokensPerCase: config.maxTokensPerCase,
+                        maxTotalTokens: config.maxTotalTokens,
+                    },
+                    childTask: {
+                        executor: "pi",
+                        role: "verifier",
+                        skills: ["playwright-cli", "webapp-testing"],
+                        toolProfile: "write",
+                        complexity: "MED",
+                        writePolicy: "exclusive",
+                        allowedPaths: [
+                            "testcase/frontend/cases/{{case.caseId}}.md",
+                            "testcase/frontend/rag/context.md",
+                            "testcase/frontend/rag/coverage-map.md",
+                            `${evidenceRoot}/{{case.caseId}}/**`,
+                        ],
+                        forbiddenPaths: forbidden,
+                        writeSet: [`${evidenceRoot}/{{case.caseId}}/**`],
+                        outputContract: "Compact JSON <=1200 characters with case status, evidence paths, error summary, and tokens.",
+                        subtaskPromptTemplate: [
+                            "Execute exactly case {{case.caseId}} from {{case.casePath}} using playwright-cli and webapp-testing. This is a fresh Pi session; do not use /new.",
+                            "Use only the declared isolated test environment. If CLI/browser/base URL/credentials/fixture isolation is missing, record blocked rather than installing tools or guessing.",
+                            "Use playwright-cli open --browser=chrome --headed <base-url>. Persist execution.md, case-result.json, screenshots/trace/video/logs under {{case.evidenceDir}} before returning.",
+                            "A business failed or blocked case is a recorded result, not a node failure. Close the session and return only compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}.",
+                        ].join("\n\n"),
+                    },
+                },
             },
             {
-                id: "review-frontend-execution-pi", depends_on: ["execute-frontend-cases-map"], role: "reviewer", executor: "pi", complexity: "HIGH", writePolicy: "read-only", allowedPaths: ["testcase/frontend/**"], forbiddenPaths: forbidden,
-                outputContract: "Read-only AC-to-case-to-browser-evidence review, including failed, blocked and token-budget-exhausted cases.", subtask_prompt: "Review the frontend case aggregate and on-disk case/evidence artifacts. A passed case requires assertion plus screenshot or equivalent browser evidence; failed/blocked cases require reasons. Do not replace browser evidence with model conclusions.",
+                id: "review-frontend-execution-pi",
+                depends_on: ["execute-frontend-cases-map"],
+                role: "reviewer",
+                executor: "pi",
+                complexity: "HIGH",
+                writePolicy: "read-only",
+                allowedPaths: ["testcase/frontend/**"],
+                forbiddenPaths: forbidden,
+                outputContract: "Read-only AC-to-case-to-browser-evidence review, including failed, blocked and token-budget-exhausted cases.",
+                subtask_prompt: "Review the frontend case aggregate and on-disk case/evidence artifacts. A passed case requires assertion plus screenshot or equivalent browser evidence; failed/blocked cases require reasons. Do not replace browser evidence with model conclusions.",
             },
             {
-                id: "frontend-test-retrospect-pi", depends_on: ["review-frontend-execution-pi"], role: "closeout", executor: "pi", toolProfile: "write", complexity: "MED", writePolicy: "exclusive", writeSet: ["docs/test-reports/**"], allowedPaths: ["testcase/frontend/**", "docs/test-reports/**"], forbiddenPaths: forbidden,
-                outputContract: "Write frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, risks, findings, and A/B/C/D rating.", subtask_prompt: "Write the frontend test retrospective under docs/test-reports/. Summarize coverage, passed/failed/blocked cases (including token-budget-exhausted), review findings, browser anomalies, residual risks, and A/B/C/D rating. Blocked cases never count as passed.",
+                id: "frontend-test-retrospect-pi",
+                depends_on: ["review-frontend-execution-pi"],
+                role: "closeout",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: "MED",
+                writePolicy: "exclusive",
+                writeSet: ["docs/test-reports/**"],
+                allowedPaths: ["testcase/frontend/**", "docs/test-reports/**"],
+                forbiddenPaths: forbidden,
+                outputContract: "Write frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, risks, findings, and A/B/C/D rating.",
+                subtask_prompt: "Write the frontend test retrospective under docs/test-reports/. Summarize coverage, passed/failed/blocked cases (including token-budget-exhausted), review findings, browser anomalies, residual risks, and A/B/C/D rating. Blocked cases never count as passed.",
             },
         ],
     };
@@ -2640,7 +3421,9 @@ export function assertSafeKnowledgeSyncFeatureId(featureId) {
     if (!KNOWLEDGE_SYNC_FEATURE_ID_RE.test(trimmed)) {
         throw new Error(`knowledge-sync featureId must match F-<id> (letters/digits/._- only); got ${JSON.stringify(featureId)}`);
     }
-    if (trimmed.includes("..") || trimmed.includes("/") || trimmed.includes("\\")) {
+    if (trimmed.includes("..") ||
+        trimmed.includes("/") ||
+        trimmed.includes("\\")) {
         throw new Error(`knowledge-sync featureId must not contain path segments: ${featureId}`);
     }
     return trimmed;
@@ -3060,7 +3843,10 @@ function buildKgBootstrapInventoryNode(sources) {
         executor: "shell",
         complexity: "LOW",
         writePolicy: "exclusive",
-        writeSet: ["knowledge/bootstrap/inventory.json", "knowledge/bootstrap/status.yaml"],
+        writeSet: [
+            "knowledge/bootstrap/inventory.json",
+            "knowledge/bootstrap/status.yaml",
+        ],
         allowedPaths: ["knowledge/bootstrap/**", "./**"],
         forbiddenPaths: commonForbiddenPaths(sources),
         outputContract: "Deterministic inventory.json under knowledge/bootstrap/ from directory and feature signals.",
@@ -3087,10 +3873,7 @@ function buildKgBootstrapProposeNode(sources) {
         toolProfile: "write",
         complexity: "HIGH",
         writePolicy: "exclusive",
-        writeSet: [
-            "knowledge/bootstrap/staging/**",
-            "knowledge/bootstrap/runs/**",
-        ],
+        writeSet: ["knowledge/bootstrap/staging/**", "knowledge/bootstrap/runs/**"],
         allowedPaths: [
             "knowledge/bootstrap/**",
             "knowledge/**",
@@ -3285,11 +4068,7 @@ function buildKgBootstrapPromoteNode(sources) {
             "knowledge/graph/**",
             "features/**",
         ],
-        forbiddenPaths: [
-            ...commonForbiddenPaths(sources),
-            "src/**",
-            "testcase/**",
-        ],
+        forbiddenPaths: [...commonForbiddenPaths(sources), "src/**", "testcase/**"],
         outputContract: "Promote staging → formal knowledge trees without overwriting existing files; copy edges.manual.yaml if absent.",
         subtask_prompt: "B5 promote: merge new files only (no overwrite of existing asserted content).",
         shell: {
@@ -3581,22 +4360,117 @@ function buildWriteSetAuditNode(sources) {
         ].join("\n\n"),
     };
 }
+function buildWriteSetAuditFormatRepairNode(sources, options) {
+    return {
+        id: options.id,
+        depends_on: [options.auditNodeId],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Plain Markdown whose first non-empty line is exactly VERDICT: pass or VERDICT: request-revision, followed by the original audit findings without substantive changes. No file writes.",
+        subtask_prompt: [
+            `Normalize the output format of ${options.auditNodeId}; this is the single read-only format-repair attempt for that audit.`,
+            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+            "If the upstream audit already contains a valid verdict, preserve it exactly. If it omitted or malformed the verdict but states an unambiguous audit conclusion, add only the matching canonical verdict and preserve the findings.",
+            "Do not add, remove, or reclassify substantive findings. If the upstream conclusion is ambiguous or cannot be preserved safely, emit VERDICT: request-revision and report the format ambiguity.",
+            "Do not infer a pass from general prose, expand task allowedPaths, or edit files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildWriteSetFormatGateNode(sources) {
+    return {
+        id: "write-set-format-gate-shell",
+        depends_on: ["write-set-audit-format-repair-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic initial write-set verdict format gate: accept pass or request-revision so the bounded plan-revision stage can run; reject missing or unexpected verdicts.",
+        subtask_prompt: "Validate the normalized initial write-set audit verdict before the bounded plan-revision stage. This gate does not authorize implementation writes.",
+        shell: {
+            commands: [],
+            verdictGate: {
+                fromNodeId: "write-set-audit-format-repair-pi",
+                accept: ["VERDICT: pass", "VERDICT: request-revision"],
+                label: "initial write-set audit format",
+                lineMode: "first-verdict-line",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildPlanRevisionNode(sources) {
+    return {
+        id: "plan-revision-pi",
+        depends_on: [
+            "write-set-format-gate-shell",
+            "plan-pi",
+            "write-set-audit-format-repair-pi",
+        ],
+        role: "planner",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "PASS_NO_REVISION_NEEDED when the normalized initial audit passed, otherwise a complete revised implementation plan with a corrected WriteSet Coverage Matrix. No file writes.",
+        subtask_prompt: [
+            "Perform the single bounded plan-revision round after the normalized initial write-set audit.",
+            "If the normalized verdict is VERDICT: pass, output PASS_NO_REVISION_NEEDED and do not change the original plan.",
+            "If it is VERDICT: request-revision, return a complete revised plan that resolves every audit finding and includes a corrected WriteSet Coverage Matrix.",
+            "Do not expand task.json.allowedPaths, weaken forbiddenPaths, or edit files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildFinalWriteSetAuditNode(sources) {
+    return {
+        id: "final-write-set-audit-pi",
+        depends_on: [
+            "plan-pi",
+            "plan-revision-pi",
+            "write-set-audit-format-repair-pi",
+        ],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision; includes final writeSet coverage findings after the single plan-revision round. No file writes.",
+        subtask_prompt: [
+            "Perform the final write-set audit after the single bounded plan-revision round.",
+            "When plan-revision-pi returned PASS_NO_REVISION_NEEDED, audit the original plan-pi output. Otherwise audit the complete revised plan.",
+            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+            "Request revision if required files still lack a single exclusive owner, writeSet is broad/placeholder, forbidden paths overlap, or any initial finding remains unresolved.",
+            "Do not expand task allowedPaths or edit files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
 function buildWriteSetGateNode(sources) {
     return {
         id: "write-set-gate-shell",
-        depends_on: ["write-set-audit-pi"],
+        depends_on: ["final-write-set-audit-format-repair-pi"],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Deterministic write-set audit verdict gate: exit 0 only when write-set-audit-pi first non-empty assistant output line is pass.",
-        subtask_prompt: "Deterministic gate: block the implementation writer unless write-set-audit-pi emitted VERDICT: pass.",
+        outputContract: "Deterministic final write-set audit verdict gate: exit 0 only when final-write-set-audit-format-repair-pi emits VERDICT: pass after the bounded revision round.",
+        subtask_prompt: "Deterministic gate: block the implementation writer unless the normalized final write-set audit emitted VERDICT: pass.",
         shell: {
             commands: [],
             verdictGate: {
-                fromNodeId: "write-set-audit-pi",
+                fromNodeId: "final-write-set-audit-format-repair-pi",
                 accept: ["VERDICT: pass"],
                 label: "write-set audit",
                 lineMode: "first-verdict-line",
@@ -3717,7 +4591,9 @@ function buildRepairNode(sources) {
             "If VERDICT: pass, return no-op with evidence. Re-run focused tests when you change code.",
             writerDeliveryContract(sources.taskConfig),
             buildSourceContextBlock(sources),
-        ].filter((value) => Boolean(value)).join("\n\n"),
+        ]
+            .filter((value) => Boolean(value))
+            .join("\n\n"),
     };
 }
 function buildHardVerifyNode(sources) {
@@ -3769,7 +4645,8 @@ function buildDecisionNode(sources) {
         outputContract: "Markdown with exactly one DECISION_ENVELOPE_JSON fenced block plus evidence summary. No file writes.",
         subtask_prompt: [
             "Return an advisory Decision Gate envelope for the supervised DAG outcome.",
-            "Include exactly one DECISION_ENVELOPE_JSON fenced block and concise evidence. Read-only: do not modify files.",
+            "Read-only: do not modify files. Review deterministic verification, review findings, write boundaries, and risks before deciding.",
+            buildDecisionEnvelopePromptContract(),
             buildSourceContextBlock(sources),
         ].join("\n\n"),
         decisionGate: { enabled: true, schemaVersion: 1, mode: "record-only" },
@@ -3807,8 +4684,26 @@ function buildSupervisedHybridDag(standard, sources) {
             cloneTask(scoutTests),
             cloneTask(plan),
             buildWriteSetAuditNode(sources),
+            buildWriteSetAuditFormatRepairNode(sources, {
+                id: "write-set-audit-format-repair-pi",
+                auditNodeId: "write-set-audit-pi",
+            }),
+            buildWriteSetFormatGateNode(sources),
+            buildPlanRevisionNode(sources),
+            buildFinalWriteSetAuditNode(sources),
+            buildWriteSetAuditFormatRepairNode(sources, {
+                id: "final-write-set-audit-format-repair-pi",
+                auditNodeId: "final-write-set-audit-pi",
+            }),
             buildWriteSetGateNode(sources),
-            cloneTask(implement, { depends_on: ["write-set-gate-shell"] }),
+            cloneTask(implement, {
+                depends_on: [
+                    "write-set-gate-shell",
+                    "plan-pi",
+                    "plan-revision-pi",
+                    "final-write-set-audit-format-repair-pi",
+                ],
+            }),
             buildSoftVerifyNode(sources),
             buildProcessSupervisorNode(sources),
             buildProcessGateNode(sources),