@tea-agent/loop-agent 0.16.25 → 0.17.0

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

@@ -7,13 +7,15 @@ import { DAG_AGENT_RUNTIME_PI_ONLY, DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1,
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
-import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
+import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, STRUCTURED_REQUIRED_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";
 import { applySddEmbeddedEnhancements, probeRepoLocalSddSkills, } from "./sdd-embedded.js";
+import { discoverProjectGovernancePresence } from "./project-governance-context.js";
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { materializeTaskReferenceDocs } from "../../task/source-references.js";
+import { observeTaskContract } from "../../task/contract/observe.js";
 import { resolveVerifyPreset } from "../../executors/shell-verification.js";
 import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
 import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "./task-demand-routing.js";
@@ -1105,6 +1107,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         executorModelMatrix: resolveExecutorModelMatrices(manifest),
         verifyCommands,
         sddEmbeddedSkills: await probeRepoLocalSddSkills(repoRoot),
+        projectGovernancePresent: await discoverProjectGovernancePresence(repoRoot),
     };
     return sources;
 }
@@ -1377,6 +1380,7 @@ function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, f
         subtask_prompt: [
             "Perform read-only Mock assessment and select one safe frontend data strategy.",
             "The first line must be exactly one of: MOCK_STRATEGY: native, MOCK_STRATEGY: browser-intercept, MOCK_STRATEGY: request-adapter, MOCK_STRATEGY: not-needed, or MOCK_STRATEGY: blocked. Do not emit blank lines, headings, or explanatory preamble before it.",
+            "Do not wrap the first line in Markdown bullets, quotes, emphasis, code fences, inline code, Chinese punctuation, or a split label/value form. Put any headings or explanation only after the exact first line.",
             "Prefer an existing native Mock facility. Use browser-intercept only with an existing browser/e2e harness. When no Mock exists but the API layer is writable, use request-adapter by adding a minimal reversible adapter/DI seam within the approved writeSet; the real adapter must remain the production default.",
             autoMaySkipMissingMock
                 ? "Auto mode may skip Mock when no project Mock capability is confirmed. Select not-needed with positive evidence from contract/scout that no project Mock capability is confirmed, continue without adding Mock files or dependencies, run the fixed verification entrypoints, and record any unproved real API behavior in Real Integration Gap. Do not block solely because no project Mock capability, browser interception harness, or request adapter exists."
@@ -1400,7 +1404,9 @@ function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, f
             "- Do not infer Mock service from lockfile-only or transitive dependency evidence.",
             "- Output MOCK_STRATEGY: blocked if capability evidence conflicts, contract fields are missing/conflicting, paths or dependencies are unauthorized, specs were not actually read, sources conflict, production-default-off cannot be proven, the API layer is not writable for a new adapter, or the frozen entrypoints cannot verify the selected strategy.",
             ...(autoMaySkipMissingMock
-                ? ["- In auto mode with no confirmed project Mock capability, do not block solely because Mock is unavailable or Mock-specific verification is absent; choose not-needed and make the Real Integration Gap explicit unless project specs require Mock or another safety rule is violated."]
+                ? [
+                    "- In auto mode with no confirmed project Mock capability, do not block solely because Mock is unavailable or Mock-specific verification is absent; choose not-needed and make the Real Integration Gap explicit unless project specs require Mock or another safety rule is violated.",
+                ]
                 : []),
             "- Never comment out or replace the real request with inline data, hard-code Mock enablement, import test mocks from a production entrypoint, invent API fields, or place secrets/real user data in fixtures.",
             "- Mock-backed behavior evidence proves the documented frontend contract only; it never proves real API integration.",
@@ -1648,11 +1654,10 @@ function pruneFrontendTasksForRisk(tasks, risk) {
     if (risk.forceFullGates || risk.selectedRisk !== "small") {
         return tasks;
     }
-    // small topology: drop first design gate + plan revision + second design cycle;
+    // small topology: drop the initial design review + conditional revision 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.
@@ -1668,8 +1673,7 @@ function pruneFrontendTasksForRisk(tasks, risk) {
                     next.push("frontend-plan-pi");
                 continue;
             }
-            if (dep === "frontend-first-design-gate-shell" ||
-                dep === "frontend-design-gate-pi") {
+            if (dep === "frontend-design-gate-pi") {
                 // skip removed gates
                 continue;
             }
@@ -1690,6 +1694,12 @@ function pruneFrontendTasksForRisk(tasks, risk) {
                 if (byId.has(need) && !depends_on.includes(need))
                     depends_on.push(need);
             }
+            return {
+                ...task,
+                depends_on,
+                dependsPolicy: "all",
+                runIf: undefined,
+            };
         }
         if (task.id === "frontend-requirement-coverage-shell") {
             const shell = task.shell?.requirementCoverageGate
@@ -1700,6 +1710,7 @@ function pruneFrontendTasksForRisk(tasks, risk) {
                         fromNodeIds: task.shell.requirementCoverageGate.fromNodeIds.map((nodeId) => nodeId === "frontend-plan-revision-pi"
                             ? "frontend-plan-pi"
                             : nodeId),
+                        fallbackFromNodeIds: undefined,
                     },
                 }
                 : task.shell;
@@ -1718,12 +1729,25 @@ function pruneFrontendTasksForRisk(tasks, risk) {
                         ? {
                             ...task.shell.jsonArtifactGate,
                             fromNodeId: "frontend-plan-pi",
+                            fallbackFromNodeIds: undefined,
                         }
                         : task.shell.jsonArtifactGate,
                 }
                 : task.shell;
             return { ...task, depends_on: nextDeps, shell };
         }
+        if (task.id === "frontend-final-design-gate-shell") {
+            const shell = task.shell?.verdictGate
+                ? {
+                    ...task.shell,
+                    verdictGate: {
+                        ...task.shell.verdictGate,
+                        fallbackFromNodeIds: undefined,
+                    },
+                }
+                : task.shell;
+            return { ...task, depends_on, dependsPolicy: "all", shell };
+        }
         if (task.id === "frontend-implement-pi") {
             // still requires final design gate
             for (const need of [
@@ -1828,7 +1852,7 @@ function buildFrontendHybridDagFromTask(sources) {
             ? [`See 执行约束.md in task source (${sources.taskId})`]
             : []),
         ...STANDARD_GLOBAL_CONSTRAINTS,
-        "Frontend implementation DAGs must pass the final design verdict gate before any write node executes; the first design gate also accepts request-revision for plan revision only.",
+        "Frontend implementation DAGs must pass the effective final design verdict gate before any write node executes; an initial pass uses the original plan, while request-revision selects the read-only revision and final-review branch.",
         "Final design gate pass is the only authorization for frontend implementation writes.",
         "Plan revision remains read-only and never edits business code.",
         "Design revision failures route to replan-and-rerun, never dev-fix.",
@@ -1960,6 +1984,8 @@ function buildFrontendHybridDagFromTask(sources) {
                 executor: "pi",
                 complexity: "MED",
                 writePolicy: "read-only",
+                outputMode: "structured-required",
+                retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
@@ -1998,53 +2024,27 @@ function buildFrontendHybridDagFromTask(sources) {
                     sourceContext,
                 ].join("\n\n"),
             },
-            {
-                id: "frontend-first-design-gate-shell",
-                depends_on: ["frontend-design-gate-pi"],
-                role: "verifier",
-                executor: "shell",
-                complexity: "LOW",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                outputContract: "Deterministic first design verdict gate: exit 0 when frontend-design-gate-pi emits VERDICT: pass or VERDICT: request-revision. Does not authorize code writes.",
-                subtask_prompt: "Deterministic gate: validate frontend-design-gate-pi first-line VERDICT is pass or request-revision; block downstream only on malformed/unexpected verdict.",
-                shell: {
-                    commands: [],
-                    verdictGate: {
-                        fromNodeId: "frontend-design-gate-pi",
-                        accept: ["VERDICT: pass", "VERDICT: request-revision"],
-                        label: "frontend first design gate",
-                        lineMode: "first-verdict-line",
-                    },
-                    cwd: ".",
-                    timeoutMs: 60000,
-                },
-            },
             {
                 id: "frontend-plan-revision-pi",
                 depends_on: [
-                    "frontend-first-design-gate-shell",
                     "frontend-plan-pi",
                     "frontend-design-gate-pi",
                     "frontend-mock-assess-pi",
                 ],
+                runIf: "$.nodes['frontend-design-gate-pi'].firstVerdictLine == 'VERDICT: request-revision'",
                 role: "planner",
                 executor: "pi",
                 complexity: "MED",
                 writePolicy: "read-only",
+                outputMode: "structured-required",
+                retryPolicy: STRUCTURED_REQUIRED_PI_RETRY_POLICY,
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                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.",
+                outputContract: "When the initial design review requests revision, return a complete 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:",
-                    "PASS_NO_REVISION_NEEDED",
-                    "The original plan from frontend-plan-pi is confirmed and does not require changes.",
-                    "Then reproduce a complete Requirement Coverage section containing every explicit REQ-/BR-/AC- identifier from the authoritative task sources so this node is the single effective-plan evidence source for the deterministic coverage gate.",
-                    "",
-                    "If the first design gate requested revision (VERDICT: request-revision), produce a complete revised implementation plan that addresses every Required Plan Correction from the design findings.",
+                    "This node runs only when frontend-design-gate-pi emitted VERDICT: request-revision. Produce a complete revised implementation plan that addresses every Required Plan Correction from the design findings.",
                     "The revised plan must include 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.",
                     requirementCoverageInstruction,
                     "Do not turn MOCK_STRATEGY: blocked into an implementable strategy without new repository or contract evidence that resolves every blocker.",
@@ -2058,7 +2058,8 @@ function buildFrontendHybridDagFromTask(sources) {
                 ? [
                     {
                         id: "frontend-requirement-coverage-shell",
-                        depends_on: ["frontend-plan-revision-pi"],
+                        depends_on: ["frontend-plan-revision-pi", "frontend-plan-pi"],
+                        dependsPolicy: "all-or-condition-skip",
                         role: "verifier",
                         executor: "shell",
                         complexity: "LOW",
@@ -2071,6 +2072,7 @@ function buildFrontendHybridDagFromTask(sources) {
                             commands: [],
                             requirementCoverageGate: {
                                 fromNodeIds: ["frontend-plan-revision-pi"],
+                                fallbackFromNodeIds: ["frontend-plan-pi"],
                                 requiredIds: requirementIds,
                                 label: "frontend requirement coverage",
                             },
@@ -2082,7 +2084,8 @@ function buildFrontendHybridDagFromTask(sources) {
                 : []),
             {
                 id: "frontend-implementation-contract-shell",
-                depends_on: ["frontend-plan-revision-pi"],
+                depends_on: ["frontend-plan-revision-pi", "frontend-plan-pi"],
+                dependsPolicy: "all-or-condition-skip",
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
@@ -2095,6 +2098,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     commands: [],
                     jsonArtifactGate: {
                         fromNodeId: "frontend-plan-revision-pi",
+                        fallbackFromNodeIds: ["frontend-plan-pi"],
                         schemaId: "frontend-implementation-contract-v1",
                         artifactName: "frontend-implementation-contract.json",
                         outputDir: "contracts",
@@ -2115,6 +2119,8 @@ function buildFrontendHybridDagFromTask(sources) {
                         ? ["frontend-requirement-coverage-shell"]
                         : []),
                 ],
+                dependsPolicy: "all-or-condition-skip",
+                runIf: "$.nodes['frontend-design-gate-pi'].firstVerdictLine == 'VERDICT: request-revision'",
                 role: "reviewer",
                 executor: "pi",
                 complexity: "MED",
@@ -2122,12 +2128,11 @@ function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_DESIGN_REVIEW_SKILLS,
-                outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by Findings and Checked Items. No file writes.",
+                outputContract: "For the effective frontend plan, return plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by Findings and Checked Items. No file writes.",
                 subtask_prompt: [
-                    "Audit the revised (or confirmed) frontend plan from frontend-plan-revision-pi before implementation.",
+                    "Audit the effective frontend plan before implementation. In the standard topology this node runs after request-revision and consumes frontend-plan-revision-pi; in a small-risk topology where that branch is pruned, audit frontend-plan-pi directly.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "If frontend-plan-revision-pi returned PASS_NO_REVISION_NEEDED, confirm the original plan against all design constraints and task requirements. Re-verify that all applicable UI states are covered, dependencies are authorized, and deterministic verification commands are present.",
-                    "If frontend-plan-revision-pi revised the plan, verify that every Required Plan Correction from the first design review has been fully addressed.",
+                    "When an initial design review requested revision, verify that every Required Plan Correction has been fully addressed. In the small-risk topology, independently audit the original plan against the full checklist because there is no initial-review finding set.",
                     "Recheck the selected Mock / API strategy, contract-to-fixture mapping, authorized paths/dependencies, explicit activation, production-default-off behavior, behavior verification, and Real Integration Gap. MOCK_STRATEGY: blocked cannot receive VERDICT: pass.",
                     "The frontend requirement coverage gate has verified that every explicit REQ-/BR-/AC- identifier remains present in the current-run plan evidence; review the mapped behavior rather than accepting identifier presence alone.",
                     "Request revision if any design gap remains, if corrections are incomplete, or if the revised plan introduces new unaddressed issues.",
@@ -2138,19 +2143,24 @@ function buildFrontendHybridDagFromTask(sources) {
             },
             {
                 id: "frontend-final-design-gate-shell",
-                depends_on: ["frontend-final-design-review-pi"],
+                depends_on: [
+                    "frontend-final-design-review-pi",
+                    "frontend-design-gate-pi",
+                ],
+                dependsPolicy: "all-or-condition-skip",
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Deterministic final design verdict gate: exit 0 only when frontend-final-design-review-pi emits VERDICT: pass. This is the sole authorization for frontend implementation writes.",
-                subtask_prompt: "Deterministic gate: block frontend implementation unless frontend-final-design-review-pi emitted VERDICT: pass.",
+                outputContract: "Deterministic effective design verdict gate: resolve the selected design review output and exit 0 only on VERDICT: pass. This is the sole authorization for frontend implementation writes.",
+                subtask_prompt: "Deterministic gate: block frontend implementation unless the effective design review emitted VERDICT: pass.",
                 shell: {
                     commands: [],
                     verdictGate: {
                         fromNodeId: "frontend-final-design-review-pi",
+                        fallbackFromNodeIds: ["frontend-design-gate-pi"],
                         accept: ["VERDICT: pass"],
                         label: "frontend final design gate",
                         lineMode: "first-verdict-line",
@@ -2169,6 +2179,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     "frontend-plan-pi",
                     "frontend-mock-assess-pi",
                 ],
+                dependsPolicy: "all-or-condition-skip",
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
@@ -2184,7 +2195,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     "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.",
+                    "frontend-final-design-gate-shell confirmed the effective initial-or-final design verdict is pass. Stay within writeSet and preserve unrelated files.",
                     "For native, browser-intercept, or request-adapter, implement contract-aligned fixtures/states and a dev/test-only activation boundary in this same writer. For not-needed, do not add Mock files or a framework and state the positive reason.",
                     "Do not write root artifacts/** unless explicitly included in writeSet. Do not claim Browser/visual verification.",
                     writerDeliveryContract(taskConfig),
@@ -2309,6 +2320,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     "frontend-failure-assess-shell",
                     implementId,
                 ],
+                runIf: "$.nodes['frontend-failure-assess-shell'].json.eligible == true",
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
@@ -2318,10 +2330,10 @@ function buildFrontendHybridDagFromTask(sources) {
                 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.",
+                outputContract: "Repair summary for an eligible repairable assessment. Must not expand writeSet, re-interpret requirements, skip tests, or enable Mock by default.",
                 subtask_prompt: [
                     "Read contracts/frontend-repair-assessment.json and the validated frontend implementation contract.",
-                    "If failedNodeIds is empty, return no-op with evidence. If eligible repairable failure, apply the smallest fix inside the original implement writeSet only.",
+                    "This node runs only for eligible=true. Apply the smallest fix for the classified repairable failure 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),
@@ -2397,6 +2409,7 @@ function buildFrontendHybridDagFromTask(sources) {
                     "frontend-repair-pi",
                     implementId,
                 ],
+                dependsPolicy: "all-or-condition-skip",
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
@@ -2404,7 +2417,7 @@ function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 outputContract: "Run-owned actual worktree diff_patch (artifacts/diff_patch.patch) plus contracts/frontend-worktree-diff.json inventory/hash for review. No product worktree writes.",
-                subtask_prompt: "Capture the authoritative actual diff after implement/repair/reverify so frontend-review-pi can audit changed files without relying on failure-path patches or model summaries.",
+                subtask_prompt: "Capture the authoritative actual diff after implementation and any selected repair/reverify branch so frontend-review-pi can audit changed files without relying on failure-path patches or model summaries.",
                 shell: {
                     commands: ["frontend-worktree-diff-gate"],
                     cwd: ".",
@@ -2419,11 +2432,15 @@ function buildFrontendHybridDagFromTask(sources) {
                     "frontend-static-reverify-shell",
                     "frontend-behavior-reverify-shell",
                     "frontend-repair-pi",
+                    "frontend-verification-trace-shell",
+                    "frontend-static-verify-shell",
+                    "frontend-behavior-verify-shell",
                     "frontend-failure-assess-shell",
                     implementId,
                     "frontend-implementation-contract-shell",
                     "frontend-contract-pi",
                     "frontend-plan-pi",
+                    "frontend-design-gate-pi",
                     "frontend-plan-revision-pi",
                     "frontend-final-design-review-pi",
                     "frontend-mock-assess-pi",
@@ -2431,6 +2448,7 @@ function buildFrontendHybridDagFromTask(sources) {
                         ? ["frontend-mock-verify-shell"]
                         : []),
                 ],
+                dependsPolicy: "all-or-condition-skip",
                 role: "reviewer",
                 executor: "pi",
                 complexity: "HIGH",
@@ -2443,9 +2461,9 @@ 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 the run-owned actual diff from frontend-worktree-diff-shell (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
+                    "Read the validated frontend-implementation-contract, the effective initial-or-post-repair frontend verification trace, the corresponding static/behavior shell facts, and the run-owned actual diff from frontend-worktree-diff-shell (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
                     "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.",
+                    "Use the direct contract and the effective plan/design branch: original plan plus initial pass when revision was skipped, or revised plan plus final design review when revision ran. 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/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case verify that the real request remains the default and the Real Integration Gap is preserved.",
                     "Inspect the production/default-real-path static evidence directly and require Mock activation to be off for that check.",
                     "Distinguish Mock-backed evidence from real API integration evidence and preserve the Real Integration Gap when the backend was not exercised.",
@@ -2486,6 +2504,9 @@ function buildFrontendHybridDagFromTask(sources) {
                     "frontend-static-reverify-shell",
                     "frontend-behavior-reverify-shell",
                     "frontend-repair-pi",
+                    "frontend-verification-trace-shell",
+                    "frontend-static-verify-shell",
+                    "frontend-behavior-verify-shell",
                     "frontend-failure-assess-shell",
                     "frontend-implementation-contract-shell",
                     "frontend-mock-assess-pi",
@@ -2493,6 +2514,7 @@ function buildFrontendHybridDagFromTask(sources) {
                         ? ["frontend-mock-verify-shell"]
                         : []),
                 ],
+                dependsPolicy: "all-or-condition-skip",
                 role: "closeout",
                 executor: "pi",
                 complexity: "MED",
@@ -2505,7 +2527,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.",
+                    "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 the effective initial-or-post-repair 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.`,
                     `When Mock was skipped in auto mode and no real API evidence passed, state exactly Frontend status: locally-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task when backend readiness matters.`,
                     "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
@@ -2707,7 +2729,7 @@ const BACKEND_TEST_CASE_MANIFEST_OUTPUT_INSTRUCTIONS = [
     "Every case must map to at least one semantically applicable explicit AC-* in acIds. If no AC applies, omit that case and bind an evidence gap to the nearest applicable acId or caseId; never emit an unbound informational gap.",
     "acIds MUST exactly match the explicit AC-* values in the written case body; do not infer ACs from Business Rules or summary matrices.",
     "Use full BE-<MODULE>-<NNN> caseId strings. Do not invent coverage percentages and do not emit coverageSummary; shell always writes the canonical summary.",
-    "Minimal shape example: {\"schemaVersion\":1,\"sourceBinding\":{\"taskId\":\"...\",\"requirementPath\":\"source/需求.md\",\"requirementSha256\":\"<64 lowercase hex>\",\"referencePaths\":[],\"requirementIds\":[\"AC-001\"]},\"cases\":[{\"caseId\":\"BE-MODULE-001\",\"acIds\":[\"AC-001\"],\"title\":\"...\",\"category\":\"positive\",\"automationStatus\":\"planned\",\"evidenceRef\":\"testcase/md/module.md\"}],\"evidenceGaps\":[]}",
+    'Minimal shape example: {"schemaVersion":1,"sourceBinding":{"taskId":"...","requirementPath":"source/需求.md","requirementSha256":"<64 lowercase hex>","referencePaths":[],"requirementIds":["AC-001"]},"cases":[{"caseId":"BE-MODULE-001","acIds":["AC-001"],"title":"...","category":"positive","automationStatus":"planned","evidenceRef":"testcase/md/module.md"}],"evidenceGaps":[]}',
 ].join("\n\n");
 function buildEmitBackendCaseManifestNode(sources, options) {
     return {
@@ -2797,7 +2819,7 @@ function buildReviewBackendCasesNode(sources, options) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(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. The deterministic gate accepts pass only; request-revision ends this run.",
+        outputContract: "advisory case review evidence whose first non-empty line is VERDICT: pass or VERDICT: request-revision; followed by Findings and Coverage Assessment. No file writes; this review neither authorizes nor blocks pytest generation.",
         subtask_prompt: [
             "Review the generated backend functional test cases under testcase/md/ and the validated Case Manifest v1.",
             "",
@@ -2828,7 +2850,7 @@ function buildReviewBackendCasesNode(sources, options) {
             "## Verdict Rules:",
             "- All Critical checks pass + Important findings ≤ 2 → VERDICT: pass",
             "- Any Critical fails OR Important > 2 → VERDICT: request-revision",
-            "- Any request-revision verdict ends the current run at the deterministic gate; describe findings clearly for an independent follow-up task.",
+            "- Any request-revision verdict is advisory evidence for canonical context, retrospective, and L-5; it does not authorize or block the pytest writer.",
             "",
             "## Output After Verdict:",
             "1. Coverage Assessment table (AC → full BE-* case IDs) using manifest + MD",
@@ -2884,8 +2906,8 @@ function buildGenerateBackendPytestNode(sources) {
     return {
         id: "generate-backend-pytest-pi",
         depends_on: [
-            "review-backend-cases-gate-shell",
-            "backend-test-execution-contract-shell",
+            "backend-test-case-manifest-shell",
+            "validate-backend-test-contracts-shell",
         ],
         role: "implementer",
         executor: "pi",
@@ -2905,11 +2927,11 @@ function buildGenerateBackendPytestNode(sources) {
         // 注意：Pi 节点超时由 executor 层控制（默认 30 分钟）
         // 如需调整，在 harness.json 的 executors.pi 中配置 modelConfig.timeoutMs
         subtask_prompt: [
-            "Convert the reviewed test cases under testcase/md/ into pytest automation code.",
+            "Convert the validated 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 cases under testcase/md/ and contracts/backend-test-case-manifest.json (case review runs independently as advisory evidence).",
+            "- Validated Backend Test Analysis v2 under contracts/backend-test-analysis.json.",
             "- 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.",
             "When targetMode is in-process (including demoted local npm/node managed servers): bootstrap the service inside function-scoped pytest fixtures under testcase/** — e.g. subprocess node server.js / startWelcomeServer with PORT=0 — and never require host-injected base URL env vars (clean-env shell will not provide WELCOME_BASE_URL / API_BASE_URL).",
@@ -3025,7 +3047,7 @@ function buildBackendTestSemanticReviewNode(sources, options = {}) {
             "Return exactly one pure JSON object with only verdict, findings, summary; no Markdown fence or surrounding prose.",
             "verdict must be pass or request-revision. Each findings[] item must contain exactly severity, caseId, testFile, testSymbol, contractRefs, issue, requiredChange.",
             "severity must be exactly Critical, Important, or Informational; contractRefs must be a non-empty string array. A request-revision verdict requires at least one finding; pass must not contain Critical findings.",
-            "Minimal shape: {\"verdict\":\"pass\",\"findings\":[],\"summary\":\"No contract-backed semantic contradiction found.\"}",
+            'Minimal shape: {"verdict":"pass","findings":[],"summary":"No contract-backed semantic contradiction found."}',
             "Check responseBody.kind (array vs object/items), ordering, field comparison (especially parseable-only date-time precision), documented status/error fields, and each caseId→symbol assertion meaning.",
             "Do not use aliases such as file, symbol, refs, finding, or requiredFix; the strict contract requires testFile, testSymbol, contractRefs, issue, requiredChange.",
             "request-revision only for concrete semantic contradiction with reviewed cases/formal analysis evidence. No style findings.",
@@ -3123,7 +3145,7 @@ function buildClassifyBackendTestResultNode(sources) {
             "Read-only classifier for Backend Test Result v1.",
             "Return exactly one JSON object (prefer pure JSON; single fenced json block tolerated; no trailing prose).",
             "The object must contain exactly category, evidence, confidence, notes. evidence must be a non-empty array of strings, confidence must be a number from 0 through 1, and notes must be a non-empty string. Do not emit schemaVersion or custom fields.",
-            "Minimal shape: {\"category\":\"Unknown\",\"evidence\":[\"outcome=completed-with-failures\"],\"confidence\":0.5,\"notes\":\"Single-run evidence is insufficient for a stronger classification.\"}",
+            'Minimal shape: {"category":"Unknown","evidence":["outcome=completed-with-failures"],"confidence":0.5,"notes":"Single-run evidence is insufficient for a stronger classification."}',
             "Read contracts/backend-test-result-initial.json (run-owned initial Result v1). Do NOT invent pass rates from raw logs.",
             "category must be one of: ProductBug, TestBug, EnvFailure, ContractMismatch, FlakyTest, Unknown.",
             "Hard constraints:",
@@ -3176,7 +3198,7 @@ function buildTestRetrospectNode(sources) {
             "- Code coverage MUST come only from the validated contracts/code-coverage-v1.json artifact generated by coverage.py/pytest-cov or JaCoCo. Show line, branch, function/method, covered, total, ratio, threshold, status, source scope, requirement IDs, tool, commit, and artifact hash.",
             "- Stability MUST come from independent Stability Evidence: use successfulRuns / recordedRuns, same suite/version, and require n≥5; a single run is unavailable.",
             "- 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.",
+            "- NEVER rewrite a failed result as passed. Result v1 is authoritative for testOutcome; pipeline completion and L-5 readiness are separate conclusions.",
             "",
             "## Report Structure:",
             "1. Maturity Rating with rationale",
@@ -3243,7 +3265,7 @@ function buildL5MetricsNode(sources) {
             "The direct upstream test-retrospect-pi output is the primary report to assess. Read it together with the run-owned Result v1, Case Manifest v1, Code Coverage v1, and Stability Evidence artifacts when present.",
             "Do not create a new DAG, rewrite the retrospective report, change test outcome, or modify any repository file.",
             "Return exactly one JSON object and no surrounding prose.",
-            "Required shape: {\"status\":\"ready\"|\"not-ready\",\"metrics\":{\"passRate\":metric,\"acCoverage\":metric,\"automationCoverage\":metric,\"stability\":metric,\"lineCoverage\":metric,\"branchCoverage\":metric,\"skipped\":metric,\"criticalRisks\":metric},\"blockingItems\":[string]}.",
+            'Required shape: {"status":"ready"|"not-ready","metrics":{"passRate":metric,"acCoverage":metric,"automationCoverage":metric,"stability":metric,"lineCoverage":metric,"branchCoverage":metric,"skipped":metric,"criticalRisks":metric},"blockingItems":[string]}.',
             "Each metric must contain numerator, denominator, ratio, threshold, status=pass|fail|unavailable, and reason (null only when passed).",
             "Use only explicit evidence. Missing or invalid required evidence is unavailable, never zero or an estimate.",
             "L-5 ready requires pass rate=100%, AC coverage=100%, automation coverage>=90%, stability>=95% with n>=5, line coverage>=80%, branch coverage>=70%, skipped=0, and zero blocking Critical risks.",
@@ -3268,75 +3290,115 @@ function buildBackendTestHybridDag(sources) {
     const globalConstraints = [
         ...taskConfig.hardConstraints,
         ...STANDARD_GLOBAL_CONSTRAINTS,
-        "backend-test-dag uses exactly 16 real top-level tasks and executes pytest exactly once.",
-        "Case and semantic request-revision verdicts fail at deterministic gates; no in-run revision or repair writer is authorized.",
-        "Analysis, execution, manifest, semantic review, single-run result, classification, canonical result, retrospective and outcome evidence remain run-owned and fail-closed.",
+        "backend-test-dag uses exactly 12 real top-level tasks and executes pytest exactly once.",
+        "Case review is advisory evidence consumed by canonical context, retrospective, and L-5; it does not authorize or block the pytest writer.",
+        "Deterministic traceability is the only generated-asset hard gate before pytest.",
+        "Analysis, execution, manifest, case review, traceability, single-run result, classification, canonical context, retrospective and L-5 evidence remain run-owned and fail-closed.",
         "Functional test case IDs must use BE-<MODULE>-<NNN> format.",
         "pytest writers may only create the initially declared testcase assets; production code, config, skip/xfail, swallowed failures and mock substitution are forbidden.",
     ];
     const analyze = buildAnalyzeInputsNode(sources);
     analyze.id = "analyze-and-discover-backend-test-pi";
-    analyze.outputContract = "Pure JSON envelope {analysis: Backend Test Analysis v2, execution: Backend Test Execution Contract v1}; no prose or writes.";
+    analyze.outputContract =
+        "Pure JSON envelope {analysis: Backend Test Analysis v2, execution: Backend Test Execution Contract v1}; no prose or writes.";
     analyze.subtask_prompt = `${analyze.subtask_prompt}\n\nAlso perform the read-only environment discovery described by Backend Test Execution Contract v1. Return exactly one JSON envelope with top-level keys analysis and execution; analysis must satisfy v2 and execution must satisfy v1.`;
     const contracts = {
-        id: "validate-backend-test-contracts-shell", depends_on: [analyze.id], role: "verifier", executor: "shell", complexity: "LOW",
-        writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources),
+        id: "validate-backend-test-contracts-shell",
+        depends_on: [analyze.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
         outputContract: "Materialize and validate contracts/backend-test-analysis.json and contracts/backend-test-execution.json.",
-        subtask_prompt: "Validate both backend-test intake contracts fail-closed.", shell: { commands: [], backendTestPipeline: "contracts", cwd: ".", timeoutMs: 60000 },
+        subtask_prompt: "Validate both backend-test intake contracts fail-closed.",
+        shell: {
+            commands: [],
+            backendTestPipeline: "contracts",
+            cwd: ".",
+            timeoutMs: 60000,
+        },
     };
     const generateCases = buildGenerateBackendFunctionalCasesNode(sources);
     generateCases.id = "generate-backend-cases-and-manifest-pi";
     generateCases.depends_on = [contracts.id];
-    generateCases.outputContract = "Write testcase/md/** and end with one fenced json Backend Test Case Manifest v1 block matching the strict field contract.";
+    generateCases.outputContract =
+        "Write testcase/md/** and end with one fenced json Backend Test Case Manifest v1 block matching the strict field contract.";
     generateCases.subtask_prompt += `\n\nAfter writing Markdown, end assistant output with exactly one fenced json block containing Backend Test Case Manifest v1 derived from the written cases.\n\n${BACKEND_TEST_CASE_MANIFEST_OUTPUT_INSTRUCTIONS}`;
-    const manifest = buildBackendTestCaseManifestGateNode(sources, { dependsOn: [generateCases.id], fromNodeId: generateCases.id });
-    const reviewCases = buildReviewBackendCasesNode(sources, { dependsOn: [manifest.id, contracts.id] });
-    const caseGate = buildReviewBackendCasesGateNode(sources);
-    caseGate.depends_on = [reviewCases.id];
-    caseGate.dependsPolicy = undefined;
-    caseGate.outputContract = "Deterministic backend case review gate: exit 0 only when the first and only review emits VERDICT: pass.";
-    caseGate.subtask_prompt = "Block pytest generation when backend case review requests revision; do not authorize an in-run writer.";
-    caseGate.shell.verdictGate = { fromNodeId: reviewCases.id, accept: ["VERDICT: pass"], label: "backend case review", lineMode: "first-verdict-line" };
+    const manifest = buildBackendTestCaseManifestGateNode(sources, {
+        dependsOn: [generateCases.id],
+        fromNodeId: generateCases.id,
+    });
+    const reviewCases = buildReviewBackendCasesNode(sources, {
+        dependsOn: [manifest.id, contracts.id, "generate-backend-pytest-pi"],
+    });
     const generatePytest = buildGenerateBackendPytestNode(sources);
-    generatePytest.depends_on = [caseGate.id, contracts.id];
-    const semanticReview = buildBackendTestSemanticReviewNode(sources, { dependsOn: [generatePytest.id, contracts.id, manifest.id] });
-    const semanticMaterialize = {
-        id: "validate-semantic-review-and-traceability-shell", depends_on: [semanticReview.id, manifest.id], role: "verifier", executor: "shell", complexity: "LOW",
-        writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Materialize the only semantic review and validate pytest traceability.", subtask_prompt: "Materialize semantic facts and traceability; verdict authorization is handled by the next deterministic gate.",
-        shell: { commands: [], backendTestPipeline: "semantic-initial", cwd: ".", timeoutMs: 60000 },
-    };
-    const semanticGate = {
-        id: "backend-test-semantic-gate-shell", depends_on: [semanticMaterialize.id, semanticReview.id], role: "verifier", executor: "shell", complexity: "LOW",
-        writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Pass-only authorization by reading contracts/backend-test-semantic-review.json; only verdict=pass proceeds to the single pytest execution.",
-        subtask_prompt: "Read the canonical semantic review artifact written by validate-semantic-review-and-traceability-shell. Authorize only when verdict is pass. Do not materialize, do not parse raw Pi Markdown or VERDICT lines, and do not authorize an in-run pytest writer.",
+    generatePytest.depends_on = [manifest.id, contracts.id];
+    const traceability = buildBackendTestTraceabilityGateNode(sources, {
+        dependsOn: [generatePytest.id, manifest.id],
+    });
+    const execute = buildExecuteBackendPytestNode(sources, {
+        id: "execute-and-parse-backend-pytest-shell",
+        dependsOn: [traceability.id, contracts.id],
+        reportStem: "backend-test-initial",
+    });
+    execute.shell.backendTestPipeline = "execute-parse-initial";
+    const classify = buildClassifyBackendTestResultNode(sources);
+    classify.depends_on = [execute.id];
+    const context = {
+        id: "materialize-classification-and-result-context-shell",
+        depends_on: [classify.id, manifest.id, reviewCases.id, traceability.id],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Materialize Classification v1, copy the unique initial Result to canonical contracts/backend-test-result.json, and emit Result + Manifest + Classification + advisory case review + traceability context.",
+        subtask_prompt: "Validate classification and materialize canonical single-run result context with auditable case review and traceability evidence, without repair eligibility or rerun.",
         shell: {
             commands: [],
-            backendTestPipeline: "semantic-initial",
+            backendTestPipeline: "classification-result-context",
             cwd: ".",
             timeoutMs: 60000,
         },
     };
-    const execute = buildExecuteBackendPytestNode(sources, { id: "execute-and-parse-backend-pytest-shell", dependsOn: [semanticGate.id, contracts.id], reportStem: "backend-test-initial" });
-    execute.shell.backendTestPipeline = "execute-parse-initial";
-    const classify = buildClassifyBackendTestResultNode(sources);
-    classify.depends_on = [execute.id];
-    const context = {
-        id: "materialize-classification-and-result-context-shell", depends_on: [classify.id, manifest.id], role: "verifier", executor: "shell", complexity: "LOW",
-        writePolicy: "read-only", allowedPaths: commonReadOnlyPaths(sources), forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Materialize Classification v1, copy the unique initial Result to canonical contracts/backend-test-result.json, and emit Result + Manifest + Classification context.",
-        subtask_prompt: "Validate classification and materialize canonical single-run result context without repair eligibility or rerun.",
-        shell: { commands: [], backendTestPipeline: "classification-result-context", cwd: ".", timeoutMs: 60000 },
-    };
     const retrospect = buildTestRetrospectNode(sources);
     retrospect.depends_on = [context.id];
     retrospect.subtask_prompt = retrospect.subtask_prompt.replaceAll("select-effective-backend-test-result-shell", context.id);
     const l5Metrics = buildL5MetricsNode(sources);
     l5Metrics.depends_on = [retrospect.id];
-    const outcome = buildBackendTestOutcomeGateNode(sources);
-    const tasks = [analyze, contracts, generateCases, manifest, reviewCases, caseGate, generatePytest, semanticReview, semanticMaterialize, semanticGate, execute, classify, context, retrospect, l5Metrics, outcome];
-    const spec = { version: 3, title: `Backend test DAG: ${taskConfig.title}`, runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT, outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE, objective: extractObjective(sources.requirementMarkdown, taskConfig.title), successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId), globalConstraints, defaults: { ...BACKEND_TEST_DEFAULTS, contextProfile: taskConfig.contextProfile }, skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE, executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS, tasks };
+    const tasks = [
+        analyze,
+        contracts,
+        generateCases,
+        manifest,
+        reviewCases,
+        generatePytest,
+        traceability,
+        execute,
+        classify,
+        context,
+        retrospect,
+        l5Metrics,
+    ];
+    const spec = {
+        version: 3,
+        title: `Backend test DAG: ${taskConfig.title}`,
+        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
+        objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
+        successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
+        globalConstraints,
+        defaults: {
+            ...BACKEND_TEST_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        tasks,
+    };
     applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
@@ -3538,7 +3600,10 @@ function buildFrontendTestHybridDag(sources) {
             subtask_prompt: "Perform the final frontend case review after the sole permitted revision. Apply the same traceability, isolation, manifest, reset, session, snapshot, and evidence checks. First verdict line must be exact; any Important or Critical finding requires request-revision. Do not write files.",
         }, {
             id: "final-frontend-case-review-gate-shell",
-            depends_on: ["review-frontend-cases-pi", "review-frontend-cases-final-pi"],
+            depends_on: [
+                "review-frontend-cases-pi",
+                "review-frontend-cases-final-pi",
+            ],
             dependsPolicy: "all-or-condition-skip",
             role: "verifier",
             executor: "shell",
@@ -3687,7 +3752,11 @@ function buildFrontendTestHybridDag(sources) {
             forbiddenPaths: forbidden,
             outputContract: "Optional quality gate: pass only when frontend-test-result-v1 is outcome=passed and integrationMode=real with 0 failed/blocked and no missing AC. Does not gate retrospective closeout.",
             subtask_prompt: "Opt-in Delivery/Worker quality gate (frontendTest.strictOutcomeGate=true). Retrospective does not depend on this node.",
-            shell: { commands: [frontendTestOutcomeGate], cwd: ".", timeoutMs: 60000 },
+            shell: {
+                commands: [frontendTestOutcomeGate],
+                cwd: ".",
+                timeoutMs: 60000,
+            },
         });
     }
     tasks.push({
@@ -4641,7 +4710,86 @@ function buildKnowledgeGraphBootstrapHybridDag(sources) {
     assertValidDagSpec(spec);
     return spec;
 }
-function buildHybridDagForTemplate(sources, template) {
+export async function requireManagedTaskContractBinding(input) {
+    const state = await observeTaskContract({
+        repoRoot: input.repoRoot,
+        taskId: input.taskId,
+    });
+    if (state.effectiveStatus !== "managed" || !state.ref) {
+        const err = new Error(`dag generate requires managed Task Contract for task ${input.taskId} (effectiveStatus=${state.effectiveStatus}); run: loop-agent task contract adopt|apply --task ${input.taskId} ...`);
+        err.code =
+            state.effectiveStatus === "externally-modified"
+                ? "EXTERNALLY_MODIFIED"
+                : "NOT_MANAGED";
+        throw err;
+    }
+    const ref = state.ref;
+    return {
+        schemaVersion: 1,
+        taskId: ref.taskId,
+        revision: ref.revision,
+        projectionVersion: ref.projectionVersion,
+        canonicalizerVersion: ref.canonicalizerVersion,
+        taskConfigSchemaVersion: ref.taskConfigSchemaVersion,
+        canonicalHash: ref.canonicalHash,
+        taskConfigSha256: ref.taskConfigSha256,
+    };
+}
+/** In-memory unit-test path only: produce a syntactically valid v4 binding. */
+function synthesizeInMemoryTaskContractBinding(sources) {
+    const requirementSha = createHash("sha256")
+        .update(sources.requirementMarkdown, "utf8")
+        .digest("hex");
+    const constraintsSha = createHash("sha256")
+        .update(sources.constraintMarkdown ?? "", "utf8")
+        .digest("hex");
+    const taskConfigSha256 = createHash("sha256")
+        .update(JSON.stringify(sources.taskConfig), "utf8")
+        .digest("hex");
+    const canonicalHash = createHash("sha256")
+        .update(JSON.stringify({
+        projectionVersion: 1,
+        canonicalizerVersion: 1,
+        taskConfigSchemaVersion: 1,
+        sourceHashes: {
+            requirementSha256: requirementSha,
+            constraintsSha256: constraintsSha,
+        },
+        taskConfigSha256,
+    }), "utf8")
+        .digest("hex");
+    return {
+        schemaVersion: 1,
+        taskId: sources.taskId,
+        revision: 1,
+        projectionVersion: 1,
+        canonicalizerVersion: 1,
+        taskConfigSchemaVersion: 1,
+        canonicalHash,
+        taskConfigSha256,
+    };
+}
+async function resolveTaskContractBindingForGenerate(sources) {
+    // Real CLI generation freezes the managed ref. Direct builder unit tests
+    // may provide repoRoot-shaped fixture paths without a persisted task; keep
+    // their deterministic synthetic binding path so topology/prompt tests remain
+    // isolated from contract storage.
+    if (sources.repoRoot) {
+        const state = await observeTaskContract({
+            repoRoot: sources.repoRoot,
+            taskId: sources.taskId,
+        });
+        if (state.effectiveStatus === "managed" && state.ref) {
+            return requireManagedTaskContractBinding({
+                repoRoot: sources.repoRoot,
+                taskId: sources.taskId,
+            });
+        }
+    }
+    return synthesizeInMemoryTaskContractBinding(sources);
+}
+async function buildHybridDagForTemplate(sources, template) {
+    const taskContractBinding = await resolveTaskContractBindingForGenerate(sources);
     let spec;
     if (template === "frontend-implementation") {
         spec = buildFrontendHybridDagFromTask(sources);
@@ -4663,12 +4811,42 @@ function buildHybridDagForTemplate(sources, template) {
         else
             spec = buildSupervisedHybridDag(standard, sources);
     }
+    applyProjectGovernanceReview(spec, template, sources);
+    // New generate path always emits DagSpec v4 + bindings.
+    spec.version = 4;
+    if (!spec.runtimeContract) {
+        spec.runtimeContract = GENERATED_DAG_RUNTIME_CONTRACT;
+    }
     spec.sourceBinding = buildDagSourceBinding(sources);
+    spec.taskContractBinding = taskContractBinding;
+    assertNoGovernanceFlagOnDisallowedTemplate(spec, template);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
 }
-export function buildHybridDagFromTask(sources, options = {}) {
+const GOVERNANCE_DISALLOWED_TEMPLATES = new Set([
+    "frontend-implementation",
+    "frontend-test-dag",
+    "backend-test-dag",
+    "knowledge-sync-dag",
+    "knowledge-graph-bootstrap-dag",
+]);
+/**
+ * Generate-time guard (constraint 2 / AC-007): the governance standard review
+ * flag must never appear on knowledge-sync, knowledge-graph-bootstrap,
+ * backend-test, or frontend tasks. Only standard verify-pi and the shared
+ * review-pi (reviewed/supervised) opt in explicitly.
+ */
+function assertNoGovernanceFlagOnDisallowedTemplate(spec, template) {
+    if (!GOVERNANCE_DISALLOWED_TEMPLATES.has(template))
+        return;
+    for (const task of spec.tasks) {
+        if (task.governanceStandardReview) {
+            throw new Error(`governanceStandardReview must not be set on ${template} task ${task.id}`);
+        }
+    }
+}
+export async function buildHybridDagFromTask(sources, options = {}) {
     const selection = resolveTaskDagTemplateSelection({
         taskKind: sources.taskConfig.taskKind,
         title: sources.taskConfig.title,
@@ -4791,6 +4969,85 @@ function buildReviewGateNode(sources) {
         },
     };
 }
+function enableProjectGovernanceOnNode(task) {
+    task.governanceStandardReview = true;
+}
+/**
+ * Apply governance only to general implementation DAGs, and only when the
+ * target repository actually contains AGENTS.md. Standard reuses verify-pi;
+ * reviewed/supervised reuse review-pi and their existing review verdict gate.
+ */
+function applyProjectGovernanceReview(spec, template, sources) {
+    if (!sources.projectGovernancePresent)
+        return;
+    if (template === "standard-dag") {
+        const verify = spec.tasks.find((task) => task.id === "verify-pi");
+        if (!verify)
+            return;
+        enableProjectGovernanceOnNode(verify);
+        insertGovernanceStandardGate(spec, sources);
+        return;
+    }
+    if (template === "review-gated-dag" ||
+        template === "supervised-implementation") {
+        const review = spec.tasks.find((task) => task.id === "review-pi");
+        if (review)
+            enableProjectGovernanceOnNode(review);
+    }
+}
+/**
+ * Deterministic governance standard gate for standard-dag closeout. It reuses
+ * the standard `verdictGate` preset (fromNodeId=verify-pi, accept
+ * ["VERDICT: pass"], first-verdict-line). When no applicable AGENTS.md/standard
+ * exists, projectGovernanceGate returns success without parsing a verdict.
+ * When an applicable mandatory standard is violated, verify-pi must emit
+ * VERDICT: request-revision and the gate blocks closeout. No new model node.
+ */
+function buildGovernanceStandardGateNode(sources) {
+    return {
+        id: "governance-standard-gate-shell",
+        depends_on: ["verify-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic governance verdict gate: exit 0 only when verify-pi first VERDICT line is pass (covers applicable mandatory standard compliance). No file writes.",
+        subtask_prompt: "Deterministic gate: block closeout unless verify-pi emitted VERDICT: pass, which requires no unresolved applicable mandatory governance-standard violation. Read-only: do not modify files.",
+        shell: {
+            commands: [],
+            projectGovernanceGate: {
+                contextPath: ".runtime/project-governance-context.json",
+            },
+            verdictGate: {
+                fromNodeId: "verify-pi",
+                accept: ["VERDICT: pass"],
+                label: "governance-standard",
+                lineMode: "first-verdict-line",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+/**
+ * Insert the governance-standard gate between verify-pi and closeout-pi in a
+ * standard DAG. Idempotent and no-op if verify-pi/closeout-pi are absent.
+ */
+function insertGovernanceStandardGate(spec, sources) {
+    const closeout = spec.tasks.find((task) => task.id === "closeout-pi");
+    const verify = spec.tasks.find((task) => task.id === "verify-pi");
+    if (!closeout || !verify)
+        return;
+    if (spec.tasks.some((task) => task.id === "governance-standard-gate-shell")) {
+        return;
+    }
+    const gate = buildGovernanceStandardGateNode(sources);
+    const closeoutIndex = spec.tasks.findIndex((task) => task.id === "closeout-pi");
+    spec.tasks.splice(closeoutIndex, 0, gate);
+    closeout.depends_on = ["governance-standard-gate-shell"];
+}
 function buildReviewGatedHybridDag(standard, sources) {
     const spec = {
         ...standard,
@@ -5216,7 +5473,7 @@ export async function writeHybridDagDraft(sources, outputPath, options = {}) {
     const preparedSources = template === "frontend-implementation"
         ? await prepareFrontendMockSources(sources)
         : sources;
-    const spec = buildHybridDagForTemplate(preparedSources, template);
+    const spec = await buildHybridDagForTemplate(preparedSources, template);
     await writeFile(outputPath, `${JSON.stringify(spec, null, 2)}\n`, "utf-8");
     return {
         taskId: sources.taskId,