@tea-agent/loop-agent 0.11.0 → 0.13.0-alpha.0

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

@@ -2,9 +2,10 @@ import { access, readdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { assertValidDagSpec } from "./validate.js";
-import { DEFAULT_DAG_OUTPUT_LANGUAGE, DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.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 { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
@@ -77,6 +78,18 @@ const FRONTEND_DESIGN_REVIEW_SKILLS = ["frontend-design-review"];
 const FRONTEND_REVIEW_SKILLS = ["frontend-review"];
 const FRONTEND_VERIFICATION_SKILLS = ["frontend-verification"];
 const IMPLEMENT_WRITESET_PLACEHOLDER = "REPLACE/WITH/NARROW/IMPLEMENT/PATHS/**";
+/**
+ * Runtime contract stamped on every newly generated DAG. Capability fields are
+ * authoritative and are the primary compatibility gate. `minimumControllerVersion`
+ * is intentionally omitted here: it is an optional diagnostic hint, and hardcoding
+ * a future version would make a controller reject the very DAGs it generates.
+ * Operators can still pin a minimum version on hand-authored specs when needed.
+ */
+export const GENERATED_DAG_RUNTIME_CONTRACT = {
+    schemaVersion: DAG_RUNTIME_CONTRACT_SCHEMA_VERSION,
+    agentRuntime: DAG_AGENT_RUNTIME_PI_ONLY,
+    repairWriterProtocol: DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1,
+};
 function resolveEnabledExecutors(manifestExecutors) {
     return Object.entries(manifestExecutors)
         .filter(([, config]) => config.enabled !== false)
@@ -605,8 +618,9 @@ export function buildStandardHybridDagFromTask(sources) {
         ...STANDARD_GLOBAL_CONSTRAINTS,
     ];
     const spec = {
-        version: 2,
+        version: 3,
         title: `Hybrid 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),
@@ -739,6 +753,7 @@ export function buildStandardHybridDagFromTask(sources) {
         ],
     };
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -758,7 +773,10 @@ function buildFrontendHybridDagFromTask(sources) {
             ? [`See 执行约束.md in task source (${sources.taskId})`]
             : []),
         ...STANDARD_GLOBAL_CONSTRAINTS,
-        "frontend-implementation DAGs must pass the design verdict gate before any write node executes.",
+        "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.",
+        "Final design gate pass is the only authorization for frontend implementation writes.",
+        "Plan revision remains read-only and never edits business code.",
+        "Design revision failures route to replan-and-rerun, never dev-fix.",
         "frontend-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.",
     ];
@@ -778,8 +796,9 @@ function buildFrontendHybridDagFromTask(sources) {
         adapterCommands: sources.verifyCommands?.final,
     });
     const spec = {
-        version: 2,
+        version: 3,
         title: `Frontend implementation DAG: ${taskConfig.title}`,
+        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
         objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
         successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
         globalConstraints,
@@ -865,7 +884,7 @@ function buildFrontendHybridDagFromTask(sources) {
                 ].join("\n\n"),
             },
             {
-                id: "frontend-design-gate-shell",
+                id: "frontend-first-design-gate-shell",
                 depends_on: ["frontend-design-gate-pi"],
                 role: "verifier",
                 executor: "shell",
@@ -873,14 +892,81 @@ function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Deterministic frontend design verdict gate: exit 0 only when frontend-design-gate-pi emits VERDICT: pass.",
-                subtask_prompt: "Deterministic gate: block frontend implementation unless frontend-design-gate-pi emitted VERDICT: pass.",
+                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"],
+                role: "planner",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                skills: FRONTEND_IMPLEMENTATION_SKILLS,
+                outputContract: "Markdown revision plan (pass case: first line PASS_NO_REVISION_NEEDED with confirmation of original plan; request-revision case: complete revised implementation plan with corrections from design findings). 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.",
+                    "",
+                    "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.",
+                    "The revised plan must include Implementation Steps, Target Files, UI State Handling, Styling / Component Strategy, Interaction Notes, Dependency Policy, Verification Plan, and Residual Risks.",
+                    "Read-only: do not modify code, docs, artifacts, or repository files. This node revises the plan only.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-final-design-review-pi",
+                depends_on: ["frontend-plan-revision-pi"],
+                role: "reviewer",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                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.",
+                subtask_prompt: [
+                    "Audit the revised (or confirmed) frontend plan from frontend-plan-revision-pi before implementation.",
+                    "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.",
+                    "Request revision if any design gap remains, if corrections are incomplete, or if the revised plan introduces new unaddressed issues.",
+                    "Read-only: do not modify repository files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-final-design-gate-shell",
+                depends_on: ["frontend-final-design-review-pi"],
+                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.",
+                shell: {
+                    commands: [],
+                    verdictGate: {
+                        fromNodeId: "frontend-final-design-review-pi",
                         accept: ["VERDICT: pass"],
-                        label: "frontend design gate",
+                        label: "frontend final design gate",
                         lineMode: "first-verdict-line",
                     },
                     cwd: ".",
@@ -889,7 +975,7 @@ function buildFrontendHybridDagFromTask(sources) {
             },
             {
                 id: implementId,
-                depends_on: ["frontend-design-gate-shell"],
+                depends_on: ["frontend-final-design-gate-shell", "frontend-plan-revision-pi", "frontend-final-design-review-pi"],
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
@@ -903,8 +989,9 @@ function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
                 outputContract: "Markdown summary with Changed Files, Implemented Behavior, UI States Covered, Styling / Component Notes, Verification Attempted, and Residual Risks.",
                 subtask_prompt: [
-                    "Implement the approved frontend plan with minimal focused changes.",
-                    "Stay within writeSet and preserve unrelated files. Do not write root artifacts/** unless explicitly included in writeSet.",
+                    "Implement the final approved frontend plan (from frontend-plan-revision-pi) with minimal focused changes.",
+                    "The frontend-final-design-review-pi verdict confirmed the plan is ready. Stay within writeSet and preserve unrelated files.",
+                    "Do not write root artifacts/** unless explicitly included in writeSet.",
                     sourceContext,
                 ].join("\n\n"),
             },
@@ -1028,6 +1115,1111 @@ function buildFrontendHybridDagFromTask(sources) {
             },
         ],
     };
+    applyDefaultReadOnlyRetryPolicy(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+// ---------------------------------------------------------------------------
+// Backend test DAG template
+// ---------------------------------------------------------------------------
+function buildAnalyzeInputsNode(sources) {
+    return {
+        id: "analyze-inputs-pi",
+        depends_on: [],
+        role: "planner",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Structured Markdown extracting core content from source documents. No file writes.",
+        subtask_prompt: [
+            "Read the task source materials and extract the following structured content for downstream test generation.",
+            "",
+            "## Required Output Sections:",
+            "",
+            "### 1. API Endpoints",
+            "List all API endpoints: Method, Path, Description, Request params, Response format.",
+            "",
+            "### 2. Data Model",
+            "For each table/collection: fields, types, constraints, descriptions.",
+            "",
+            "### 3. Business Logic",
+            "Core business rules, validation rules, calculation formulas.",
+            "",
+            "### 4. State Transitions",
+            "State machines (e.g. order status: pending → paid → shipped → completed).",
+            "",
+            "### 5. Error Scenarios & Error Codes",
+            "All error codes, error messages, and when they occur.",
+            "",
+            "### 6. External Dependencies",
+            "Third-party services, databases, message queues. Include timeout settings if documented.",
+            "",
+            "### 7. Acceptance Criteria",
+            "Extract ALL acceptance criteria from 需求.md. Number them AC-001, AC-002, etc. If not explicitly listed, derive from functional requirements.",
+            "",
+            "### 8. Risk Areas",
+            "High-risk areas requiring extra test coverage.",
+            "",
+            "## Conditional Sections (include ONLY if mentioned in requirements):",
+            "- Authentication & Authorization: include ONLY if requirements mention auth mechanism (JWT, OAuth2, API Key, etc.)",
+            "- Timeout Handling: include ONLY if requirements mention timeout configuration or degradation strategy",
+            "- Concurrency & Idempotency: include ONLY if requirements mention concurrency, idempotency rules, or locking mechanisms",
+            "- State Transitions: include ONLY if requirements mention business state machines",
+            "- If not mentioned in requirements, do NOT include these sections",
+            "",
+            "This output will be used directly by downstream nodes. Be thorough and structured.",
+            "Read-only: do not modify code, docs, artifacts, or repository files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildGenerateBackendFunctionalCasesNode(sources) {
+    return {
+        id: "generate-backend-functional-cases-pi",
+        depends_on: ["analyze-inputs-pi"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/md/**"],
+        allowedPaths: ["testcase/md/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        // 注意：Pi 节点超时由 executor 层控制（默认 30 分钟）
+        // 如需调整，在 harness.json 的 executors.pi 中配置 modelConfig.timeoutMs
+        subtask_prompt: [
+            "Based on the upstream analyze-inputs-pi output, generate structured backend functional test cases.",
+            "",
+            "## Output Steps (do in order):",
+            "1. First, output a brief summary: how many modules, how many cases planned per module",
+            "2. Then write each test case file under testcase/md/",
+            "",
+            "## Format Rules:",
+            "- Each test case ID: BE-<MODULE>-<NNN> (e.g. BE-ORDER-001)",
+            "- Each file covers one module",
+            "- Case structure: ID, Title, Precondition, Steps, Expected Result",
+            "- Map each case to acceptance criteria (AC-xxx)",
+            "",
+            "## Coverage Requirements:",
+            "- Positive paths: happy path for each acceptance criterion",
+            "- Negative paths: error scenarios (invalid input, not found, state violations)",
+            "- Boundary conditions: empty input, max length, edge values",
+            "",
+            "## Conditional Coverage (include ONLY if mentioned in upstream analysis):",
+            "- State transitions: include ONLY if upstream analyze-inputs-pi mentions state machine",
+            "- Authentication scenarios: include ONLY if upstream analyze-inputs-pi mentions auth mechanism",
+            "- Timeout scenarios: include ONLY if upstream analyze-inputs-pi mentions timeout handling",
+            "- Concurrency scenarios: include ONLY if upstream analyze-inputs-pi mentions concurrency/idempotency rules",
+            "- If not mentioned, do NOT generate these test cases",
+            "",
+            "## Constraints:",
+            "- Stay within writeSet: testcase/md/**",
+            "- Do NOT re-read source documents — use the upstream analyze-inputs-pi output only",
+            "- Do not write root artifacts/**",
+        ].join("\n\n"),
+    };
+}
+function buildReviewBackendCasesNode(sources) {
+    return {
+        id: "review-backend-cases-pi",
+        depends_on: ["generate-backend-functional-cases-pi"],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "HIGH",
+        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.",
+        subtask_prompt: [
+            "Review the generated backend functional test cases under testcase/md/.",
+            "",
+            "## Mandatory First Line:",
+            "First non-empty line must be exactly: VERDICT: pass or VERDICT: request-revision",
+            "",
+            "## Review Checklist:",
+            "- 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)",
+            "- Boundary coverage: edge cases (empty, max length, edge values)",
+            "- Traceability: each AC maps to at least one case ID",
+            "- Case structure: ID, Title, Precondition, Steps, Expected Result",
+            "- No duplicate IDs across files",
+            "",
+            "## Conditional Coverage (check ONLY if mentioned in upstream analysis):",
+            "- State transition coverage: check ONLY if analyze-inputs-pi mentions state machine",
+            "- Authentication coverage: check ONLY if analyze-inputs-pi mentions auth mechanism",
+            "- Timeout coverage: check ONLY if analyze-inputs-pi mentions timeout handling",
+            "- Concurrency coverage: check ONLY if analyze-inputs-pi mentions concurrency/idempotency rules",
+            "- If not mentioned, do NOT flag as missing",
+            "",
+            "## Verdict Rules:",
+            "- All Critical checks pass + Important findings ≤ 2 → VERDICT: pass",
+            "- Any Critical fails OR Important > 2 → VERDICT: request-revision",
+            "",
+            "## Output After Verdict:",
+            "1. Coverage Assessment table (AC → case IDs)",
+            "2. Findings list (Critical/Important/Informational)",
+            "3. Statistics (total cases, positive/negative/boundary breakdown)",
+            "",
+            "## Constraints:",
+            "- Read-only: do not modify files",
+            "- Do NOT re-read source documents — use upstream analyze-inputs-pi output for acceptance criteria",
+            "- Use testcase/md/ files for case review",
+        ].join("\n\n"),
+    };
+}
+function buildReviewBackendCasesGateNode(sources) {
+    return {
+        id: "review-backend-cases-gate-shell",
+        depends_on: ["review-backend-cases-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic backend case review gate: exit 0 only when review-backend-cases-pi emits VERDICT: pass.",
+        subtask_prompt: "Deterministic gate: block pytest generation unless backend case review emitted VERDICT: pass.",
+        shell: {
+            commands: [],
+            verdictGate: {
+                fromNodeId: "review-backend-cases-pi",
+                accept: ["VERDICT: pass"],
+                label: "backend case review",
+                lineMode: "first-verdict-line",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildGenerateBackendPytestNode(sources) {
+    return {
+        id: "generate-backend-pytest-pi",
+        depends_on: ["review-backend-cases-gate-shell"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "HIGH",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/**/test_*.py"],
+        allowedPaths: ["testcase/**/test_*.py"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        // 注意：Pi 节点超时由 executor 层控制（默认 30 分钟）
+        // 如需调整，在 harness.json 的 executors.pi 中配置 modelConfig.timeoutMs
+        subtask_prompt: [
+            "Convert the reviewed test cases under testcase/md/ into pytest automation code.",
+            "",
+            "## 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/",
+            "",
+            "## Format Rules:",
+            "- File prefix: test_<module>.py",
+            "- Function name: test_BE_<MODULE>_<NNN>_<description>",
+            "- Docstring first line: BE-<MODULE>-<NNN>: <Case Title>",
+            "- 1:1 mapping: each functional case → one pytest function",
+            "",
+            "## Implementation Rules:",
+            "- Use assert statements, not unittest assertions",
+            "- Assert specific values, not just 'no exception'",
+            "- Use @pytest.mark.parametrize for boundary cases",
+            "- Use markers: @pytest.mark.positive, @pytest.mark.negative, @pytest.mark.boundary",
+            "",
+            "## Conditional Implementation (include ONLY if test cases exist):",
+            "- Authentication tests: implement ONLY if testcase/md/ contains auth-related cases",
+            "- Timeout tests: implement ONLY if testcase/md/ contains timeout-related cases",
+            "- Use @pytest.mark.auth for auth tests, @pytest.mark.timeout for timeout tests",
+            "- If no such cases exist, do NOT add these tests",
+            "",
+            "## Constraints:",
+            "- Only create NEW files, do NOT modify existing framework files (conftest.py, pytest.ini, pyproject.toml)",
+            "- If filename exists, add suffix: test_order.py → test_order_01.py",
+            "- Stay within writeSet: testcase/**/test_*.py",
+            "- Do NOT re-read source documents — use the reviewed cases under testcase/md/ only",
+            "- Read existing conftest.py/pytest.ini to understand conventions, but do NOT modify them",
+        ].join("\n\n"),
+    };
+}
+function buildExecuteBackendPytestNode(sources) {
+    return {
+        id: "execute-backend-pytest-shell",
+        depends_on: ["generate-backend-pytest-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Archived pytest stdout/stderr with exit codes and HTML report path; no source or test file modifications.",
+        subtask_prompt: "Run pytest for the backend test suite and capture results.",
+        shell: {
+            commands: [
+                "python -m pytest testcase/ --html=reports/backend-test-report.html -v",
+            ],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [
+                    "python -m pytest testcase/ --html=reports/backend-test-report.html -v",
+                ],
+                finalFullRequired: true,
+            }),
+            cwd: ".",
+            timeoutMs: 300000,
+        },
+    };
+}
+function buildTestRetrospectNode(sources) {
+    return {
+        id: "test-retrospect-pi",
+        depends_on: ["execute-backend-pytest-shell"],
+        role: "closeout",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["docs/test-reports/**"],
+        allowedPaths: ["docs/test-reports/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        subtask_prompt: [
+            "Read upstream outputs (review report + pytest results) 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/",
+            "",
+            "## Report Structure:",
+            "1. Maturity Rating with rationale",
+            "2. Test Coverage Summary (total cases, pass rate, failed case analysis)",
+            "3. Review Findings and resolution status",
+            "4. Failed Test Analysis (if any)",
+            "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",
+            "- D: below C thresholds",
+            "",
+            "## Constraints:",
+            "- Stay within writeSet: docs/test-reports/**",
+            "- Do NOT re-read source documents — use upstream outputs only",
+            "- Do not write root artifacts/**",
+        ].join("\n\n"),
+    };
+}
+const BACKEND_TEST_DEFAULTS = {
+    ...HYBRID_DEFAULTS,
+    writePolicy: "read-only",
+};
+const BACKEND_TEST_SKILLS_BY_ROLE = {
+    planner: ["loop-agent"],
+    scout: [],
+    implementer: ["test-driven-development", "verification-before-completion"],
+    reviewer: ["requesting-code-review", "code-review-core"],
+    verifier: ["verification-before-completion", "systematic-debugging"],
+    closeout: ["loop-agent", "verification-before-completion"],
+};
+function buildBackendTestHybridDag(sources) {
+    const { taskConfig } = sources;
+    const sourceContext = buildSourceContextBlock(sources);
+    const readOnlyPaths = commonReadOnlyPaths(sources);
+    const forbiddenPaths = commonForbiddenPaths(sources);
+    const globalConstraints = [
+        ...taskConfig.hardConstraints,
+        ...(sources.constraintMarkdown
+            ? [`See 执行约束.md in task source (${sources.taskId})`]
+            : []),
+        ...STANDARD_GLOBAL_CONSTRAINTS,
+        "backend-test-dag nodes must maintain traceability from requirements to functional cases to pytest automation.",
+        "Functional test case IDs must use BE-<MODULE>-<NNN> format.",
+        "pytest execution must produce HTML reports under reports/.",
+        "pytest automation scripts must use test_ filename prefix for pytest discovery.",
+        "generate-backend-pytest-pi must only create new test files under testcase/; modifying existing framework files (conftest.py, pytest.ini, pyproject.toml) is forbidden.",
+        "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.",
+    ];
+    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,
+        convergence: {
+            enabled: true,
+            maxPasses: 3,
+            stopOnVerdictPass: true,
+            stopOnHardVerifyPass: true,
+            pauseOnRegression: true,
+            chainNodeIds: [
+                "generate-backend-functional-cases-pi",
+                "review-backend-cases-pi",
+                "review-backend-cases-gate-shell",
+            ],
+        },
+        defaults: {
+            ...BACKEND_TEST_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        tasks: [
+            buildAnalyzeInputsNode(sources),
+            buildGenerateBackendFunctionalCasesNode(sources),
+            buildReviewBackendCasesNode(sources),
+            buildReviewBackendCasesGateNode(sources),
+            buildGenerateBackendPytestNode(sources),
+            buildExecuteBackendPytestNode(sources),
+            buildTestRetrospectNode(sources),
+        ],
+    };
+    applyDefaultReadOnlyRetryPolicy(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+// ---------------------------------------------------------------------------
+// Knowledge-sync DAG template
+// ---------------------------------------------------------------------------
+const KNOWLEDGE_SYNC_DEFAULTS = {
+    ...HYBRID_DEFAULTS,
+    writePolicy: "read-only",
+};
+const KNOWLEDGE_SYNC_SKILLS_BY_ROLE = {
+    planner: ["loop-agent"],
+    scout: [],
+    implementer: ["verification-before-completion"],
+    reviewer: ["requesting-code-review"],
+    verifier: ["verification-before-completion", "systematic-debugging"],
+    closeout: ["loop-agent", "verification-before-completion"],
+};
+/** Safe Feature directory id: F-… without path separators. */
+const KNOWLEDGE_SYNC_FEATURE_ID_RE = /^F-[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export function assertSafeKnowledgeSyncFeatureId(featureId) {
+    const trimmed = featureId.trim();
+    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("\\")) {
+        throw new Error(`knowledge-sync featureId must not contain path segments: ${featureId}`);
+    }
+    return trimmed;
+}
+/**
+ * Resolve featureId for knowledge-sync writeSet binding (fail-closed).
+ * Order: task.json featureId → hardConstraints key → requirement body F-YYYY-… → taskId if F-*.
+ */
+export function resolveKnowledgeSyncFeatureId(sources) {
+    const candidates = [];
+    const fromConfig = sources.taskConfig.featureId?.trim();
+    if (fromConfig)
+        candidates.push(fromConfig);
+    for (const line of sources.taskConfig.hardConstraints ?? []) {
+        const match = line.match(/(?:featureId|feature_id)\s*[=:]\s*(F-[A-Za-z0-9][A-Za-z0-9._-]*)/i);
+        if (match?.[1])
+            candidates.push(match[1]);
+    }
+    const fromRequirement = sources.requirementMarkdown?.match(/\b(F-\d{4}-\d{2,})\b/);
+    if (fromRequirement?.[1])
+        candidates.push(fromRequirement[1]);
+    if (KNOWLEDGE_SYNC_FEATURE_ID_RE.test(sources.taskId)) {
+        candidates.push(sources.taskId);
+    }
+    for (const candidate of candidates) {
+        try {
+            return assertSafeKnowledgeSyncFeatureId(candidate);
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    throw new Error([
+        "knowledge-sync requires an explicit featureId bound to features/<featureId>/.",
+        'Set task.json "featureId": "F-YYYY-NNN", or hardConstraints entry featureId=F-…,',
+        "or put F-YYYY-NNN in 需求.md, or use a taskId that is already an F-* id.",
+    ].join(" "));
+}
+function knowledgeSyncWriteSet(featureId) {
+    const id = assertSafeKnowledgeSyncFeatureId(featureId);
+    return [
+        `features/${id}/testing/**`,
+        `features/${id}/requirement-delta.md`,
+        "docs/test-reports/**",
+    ];
+}
+function knowledgeSyncPendingWriteSet(featureId) {
+    const id = assertSafeKnowledgeSyncFeatureId(featureId);
+    return [`features/${id}/testing/sync/pending/**`];
+}
+function knowledgeSyncPointerWriteSet(featureId) {
+    const id = assertSafeKnowledgeSyncFeatureId(featureId);
+    return [
+        `features/${id}/testing/runs/**`,
+        `features/${id}/testing/sync/applied/**`,
+    ];
+}
+function knowledgeSyncDraftRelPath(featureId) {
+    const id = assertSafeKnowledgeSyncFeatureId(featureId);
+    return `features/${id}/testing/sync/pending/knowledge-sync-draft.json`;
+}
+function buildKnowledgeSyncCollectNode(sources, featureId) {
+    return {
+        id: "knowledge-sync-collect-pi",
+        depends_on: [],
+        role: "planner",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Plain Markdown inventory of final-verification evidence, acceptance criteria, cases, defects, and requirement-delta candidates; no file writes.",
+        subtask_prompt: [
+            "Collect inputs for knowledge-sync after final verification.",
+            `Bound featureId for this run: ${featureId} (directory features/${featureId}/).`,
+            `Read task source (需求.md, 执行约束.md, references), features/${featureId}/ testing assets when present, and upstream final verification / pytest / retrospect evidence paths.`,
+            "Produce a concise inventory covering: featureId/taskId/runId/headSha, AC list, reviewed cases, automation bindings, open defects, requirement-delta risk, and missing evidence.",
+            "Do not claim final verification passed without shell evidence. Read-only: do not modify repository files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildKnowledgeSyncDraftNode(sources, featureId) {
+    const pending = knowledgeSyncPendingWriteSet(featureId);
+    const draftPath = knowledgeSyncDraftRelPath(featureId);
+    return {
+        id: "knowledge-sync-draft-pi",
+        depends_on: ["knowledge-sync-collect-pi"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "HIGH",
+        writePolicy: "exclusive",
+        writeSet: pending,
+        allowedPaths: pending,
+        forbiddenPaths: commonForbiddenPaths(sources),
+        subtask_prompt: [
+            "Using knowledge-sync-collect-pi inventory and final verification evidence, write the pending knowledge-sync draft for this Feature only.",
+            `featureId MUST be exactly ${featureId}. Write only under features/${featureId}/testing/sync/pending/.`,
+            `Create ${draftPath} (schemaVersion 1) and features/${featureId}/testing/sync/pending/knowledge-sync-draft.md human summary.`,
+            "Draft payload must include: acceptanceVerdict, coverageMatrix, caseIndex, automationMap, defects, requirementDelta (or null), retrospectiveRef, evidencePointers, and operations[] with op/target/risk/reason.",
+            `Every operations[].target path must stay under features/${featureId}/ or docs/test-reports/.`,
+            "Mark requirement/acceptance body edits as risk=high. Keep raw shell logs as path pointers only.",
+            "If final verification is not pass, still write draft but set gates.blockIfFinalVerificationNotPass accordingly and do not invent pass results.",
+            "Stay within writeSet. Do not write other features/**, src/**, .harness/**, or knowledge/testing/standards/**.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildKnowledgeSyncValidateNode(sources, featureId) {
+    const draftPath = knowledgeSyncDraftRelPath(featureId);
+    const validateScript = [
+        "node",
+        "-e",
+        JSON.stringify([
+            "const fs=require('fs');",
+            "const path=require('path');",
+            `const featureId=${JSON.stringify(featureId)};`,
+            `const file=${JSON.stringify(draftPath)};`,
+            "if(!fs.existsSync(file)){ console.error('knowledge-sync validate: missing draft at '+file); process.exit(1); }",
+            "let draft; try { draft=JSON.parse(fs.readFileSync(file,'utf8')); } catch(e){ console.error('invalid JSON',file,e.message); process.exit(1); }",
+            "let failed=false;",
+            "if(draft.schemaVersion!==1){ console.error(file+': schemaVersion must be 1'); failed=true; }",
+            "for (const key of ['featureId','taskId','runId','finalVerification','operations','payload','gates']) {",
+            "  if(draft[key]===undefined||draft[key]===null){ console.error(file+': missing '+key); failed=true; }",
+            "}",
+            "if(draft.featureId!==featureId){ console.error(file+': featureId must be '+featureId+' got '+draft.featureId); failed=true; }",
+            "if(!Array.isArray(draft.operations)||draft.operations.length===0){ console.error(file+': operations must be non-empty array'); failed=true; }",
+            "const prefix='features/'+featureId+'/';",
+            "for (const op of draft.operations||[]) {",
+            "  const t=op&&op.target; if(typeof t!=='string'){ console.error('op missing target'); failed=true; continue; }",
+            "  const ok=t===prefix.slice(0,-1)||t.startsWith(prefix)||t.startsWith('docs/test-reports/');",
+            "  if(!ok){ console.error('op.target outside feature bind: '+t); failed=true; }",
+            "}",
+            "const highRisk=(draft.operations||[]).some((op)=>op && op.risk==='high');",
+            "if(draft.gates && draft.gates.blockIfFinalVerificationNotPass && draft.finalVerification!=='pass' && draft.finalVerification!=='pass-with-waivers'){",
+            "  console.error(file+': finalVerification is not pass'); failed=true;",
+            "}",
+            "if(highRisk && draft.gates && draft.gates.requireHumanIfHighRisk){",
+            "  console.log(file+': high-risk ops present; human approval required before/while apply');",
+            "}",
+            "if(failed) process.exit(1);",
+            "console.log('knowledge-sync validate ok '+file);",
+        ].join("")),
+    ].join(" ");
+    return {
+        id: "knowledge-sync-validate-shell",
+        depends_on: ["knowledge-sync-draft-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: [
+            ...commonReadOnlyPaths(sources),
+            `features/${featureId}/testing/sync/pending/**`,
+        ],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: `Deterministic validation of ${draftPath} (schema, featureId bind, operation targets, finalVerification gate); no worktree writes.`,
+        subtask_prompt: `Validate only ${draftPath} for featureId=${featureId} before apply.`,
+        shell: {
+            commands: [validateScript],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [validateScript],
+                finalFullRequired: true,
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+function buildKnowledgeSyncApplyNode(sources, featureId) {
+    const writeSet = knowledgeSyncWriteSet(featureId);
+    const draftPath = knowledgeSyncDraftRelPath(featureId);
+    return {
+        id: "knowledge-sync-apply-pi",
+        depends_on: ["knowledge-sync-validate-shell"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "HIGH",
+        writePolicy: "exclusive",
+        writeSet,
+        allowedPaths: writeSet,
+        forbiddenPaths: [
+            ...commonForbiddenPaths(sources),
+            "src/**",
+            "knowledge/testing/standards/**",
+            "conftest.py",
+            "pytest.ini",
+            "pyproject.toml",
+        ],
+        subtask_prompt: [
+            "Apply the validated knowledge-sync draft into the Feature testing knowledge base (L1).",
+            `Bound featureId: ${featureId}. Only touch features/${featureId}/ and docs/test-reports/** (writeSet is exclusive).`,
+            `From ${draftPath}, upsert under features/${featureId}/:`,
+            "- testing/acceptance-verdict.yaml",
+            "- testing/coverage-matrix.yaml",
+            "- testing/cases/** and index.yaml when payload includes caseIndex",
+            "- testing/automation-map.yaml",
+            "- testing/defects/registry.yaml and open.md",
+            "- testing/closeout-testing.md and retrospectives when provided",
+            `- features/${featureId}/requirement-delta.md only as draft/proposal unless operations mark approved product change`,
+            "Never modify other features/**, knowledge/testing/standards/**, src/**, or pytest framework files.",
+            "Do not invent AC pass without evidencePointers. Keep raw logs as pointers only.",
+            "If high-risk requirement changes lack approval, write requirement-delta.md as draft and do not merge into requirement.md/acceptance.yaml.",
+            "Stay within writeSet.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildKnowledgeSyncPointerNode(sources, featureId) {
+    const writeSet = knowledgeSyncPointerWriteSet(featureId);
+    return {
+        id: "knowledge-sync-pointer-pi",
+        depends_on: ["knowledge-sync-apply-pi"],
+        role: "closeout",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet,
+        allowedPaths: writeSet,
+        forbiddenPaths: commonForbiddenPaths(sources),
+        subtask_prompt: [
+            "Write knowledge-sync audit pointers after apply.",
+            `Update features/${featureId}/testing/runs/latest.md with runId, headSha, finalVerification, maturity, evidence paths, and applied artifact refs.`,
+            `Write features/${featureId}/testing/sync/applied/KS-<timestamp>.json summarizing applied operations and source draft hash/path.`,
+            "Do not rewrite acceptance-verdict or cases here unless only adding pointer fields already applied.",
+            "Stay within writeSet. Do not touch other features. Read-only regarding src/** and .harness/**.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildKnowledgeSyncHybridDag(sources) {
+    const { taskConfig } = sources;
+    const featureId = resolveKnowledgeSyncFeatureId(sources);
+    const globalConstraints = [
+        ...taskConfig.hardConstraints,
+        ...(sources.constraintMarkdown
+            ? [`See 执行约束.md in task source (${sources.taskId})`]
+            : []),
+        ...STANDARD_GLOBAL_CONSTRAINTS,
+        `knowledge-sync-dag is bound to featureId=${featureId}; writes only features/${featureId}/testing/**, features/${featureId}/requirement-delta.md, and docs/test-reports/**.`,
+        "knowledge-sync must not modify other features/**, src/**, .harness/**, knowledge/testing/standards/**, or pytest framework files.",
+        "Apply is blocked unless knowledge-sync-validate-shell passes; final verification evidence remains the completion authority.",
+        "High-risk requirement/acceptance body changes require human approval via requirement-delta; do not silently rewrite requirement.md.",
+        "Raw shell logs stay as path pointers; knowledge base stores stable facts only.",
+        "Prefer structured YAML/Markdown L1 knowledge pack over vector-store-only writes.",
+    ];
+    const spec = {
+        version: 2,
+        title: `Knowledge-sync DAG (${featureId}): ${taskConfig.title}`,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
+        objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
+        successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
+        globalConstraints,
+        defaults: {
+            ...KNOWLEDGE_SYNC_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: KNOWLEDGE_SYNC_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        tasks: [
+            buildKnowledgeSyncCollectNode(sources, featureId),
+            buildKnowledgeSyncDraftNode(sources, featureId),
+            buildKnowledgeSyncValidateNode(sources, featureId),
+            buildKnowledgeSyncApplyNode(sources, featureId),
+            buildKnowledgeSyncPointerNode(sources, featureId),
+        ],
+    };
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+// ---------------------------------------------------------------------------
+// Knowledge-graph bootstrap DAG template (AI-assisted graph initialization)
+// ---------------------------------------------------------------------------
+const KG_BOOTSTRAP_DEFAULTS = {
+    ...HYBRID_DEFAULTS,
+    writePolicy: "read-only",
+};
+const KG_BOOTSTRAP_SKILLS_BY_ROLE = {
+    planner: ["loop-agent"],
+    scout: ["codebase-scout"],
+    implementer: ["verification-before-completion"],
+    reviewer: ["requesting-code-review"],
+    verifier: ["verification-before-completion", "systematic-debugging"],
+    closeout: ["loop-agent", "verification-before-completion"],
+};
+function buildKgBootstrapInlineNodeScript(lines) {
+    return ["node", "-e", JSON.stringify(lines.join(""))].join(" ");
+}
+function buildKgBootstrapPreflightNode(sources) {
+    const script = buildKgBootstrapInlineNodeScript([
+        "const fs=require('fs');",
+        "const path=require('path');",
+        "const root=process.cwd();",
+        "const scope=path.join(root,'knowledge','bootstrap','scope.yaml');",
+        "const status=path.join(root,'knowledge','bootstrap','status.yaml');",
+        "const staging=path.join(root,'knowledge','bootstrap','staging');",
+        "function ensureDir(p){fs.mkdirSync(p,{recursive:true});}",
+        "ensureDir(path.join(root,'knowledge','bootstrap','runs'));",
+        "ensureDir(staging);",
+        "ensureDir(path.join(root,'knowledge','graph'));",
+        "if(!fs.existsSync(scope)){",
+        "  console.error('kg-bootstrap preflight: missing knowledge/bootstrap/scope.yaml — complete B0/B1 skeleton first');",
+        "  process.exit(1);",
+        "}",
+        "if(!fs.existsSync(status)){",
+        "  console.error('kg-bootstrap preflight: missing knowledge/bootstrap/status.yaml');",
+        "  process.exit(1);",
+        "}",
+        "console.log('kg-bootstrap preflight ok');",
+    ]);
+    return {
+        id: "kg-bootstrap-preflight-shell",
+        depends_on: [],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ["knowledge/bootstrap/**", "knowledge/graph/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Preflight: require knowledge/bootstrap/scope.yaml and status.yaml; ensure staging/runs/graph dirs exist.",
+        subtask_prompt: "Fail if bootstrap skeleton is missing. Do not invent business entities.",
+        shell: {
+            commands: [script],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "intermediate",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [script],
+            }),
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildKgBootstrapInventoryNode(sources) {
+    const script = buildKgBootstrapInlineNodeScript([
+        "const fs=require('fs');",
+        "const path=require('path');",
+        "const root=process.cwd();",
+        "const out=path.join(root,'knowledge','bootstrap','inventory.json');",
+        "function listDir(rel){const p=path.join(root,rel);if(!fs.existsSync(p))return[];return fs.readdirSync(p,{withFileTypes:true}).map(e=>({name:e.name,dir:e.isDirectory()}));}",
+        "const top=listDir('.').filter(e=>e.dir).map(e=>e.name).filter(n=>!['node_modules','.git','dist','.harness'].includes(n));",
+        "const features=listDir('features').filter(e=>e.dir&&/^F-/.test(e.name)).map(e=>e.name);",
+        "const services=[];",
+        "for (const base of ['services','apps','packages']) {",
+        "  for (const e of listDir(base)) if(e.dir) services.push({candidateName:e.name,paths:[base+'/'+e.name+'/**'],evidence:[base+'/'+e.name]});",
+        "}",
+        "const manifests=['package.json','go.mod','pyproject.toml','pom.xml','Cargo.toml'].filter(f=>fs.existsSync(path.join(root,f)));",
+        "const inventory={schemaVersion:1,generatedAt:new Date().toISOString(),signals:{packageManifests:manifests,topLevelDirs:top,featureIds:features,likelyServices:services,docHits:[],openApiOrProto:[],existingKnowledge:{hasDomains:fs.existsSync(path.join(root,'knowledge','domains')),hasServices:fs.existsSync(path.join(root,'knowledge','services')),hasGraph:fs.existsSync(path.join(root,'knowledge','graph','edges.yaml'))}},limits:{maxFilesScanned:0,truncated:false}};",
+        "fs.mkdirSync(path.dirname(out),{recursive:true});",
+        "fs.writeFileSync(out,JSON.stringify(inventory,null,2)+'\\n');",
+        "console.log('wrote '+out+' features='+features.length+' serviceCandidates='+services.length);",
+    ]);
+    return {
+        id: "kg-bootstrap-inventory-shell",
+        depends_on: ["kg-bootstrap-preflight-shell"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "exclusive",
+        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.",
+        subtask_prompt: "Scan repository structure into knowledge/bootstrap/inventory.json (B2).",
+        shell: {
+            commands: [script],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "intermediate",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [script],
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+function buildKgBootstrapProposeNode(sources) {
+    return {
+        id: "kg-bootstrap-propose-pi",
+        depends_on: ["kg-bootstrap-inventory-shell"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "HIGH",
+        writePolicy: "exclusive",
+        writeSet: [
+            "knowledge/bootstrap/staging/**",
+            "knowledge/bootstrap/runs/**",
+        ],
+        allowedPaths: [
+            "knowledge/bootstrap/**",
+            "knowledge/**",
+            "features/**",
+            "docs/**",
+            "README.md",
+            "services/**",
+            "apps/**",
+            "packages/**",
+            "src/**",
+        ],
+        forbiddenPaths: [
+            ...commonForbiddenPaths(sources),
+            "knowledge/domains/**",
+            "knowledge/services/**",
+            "knowledge/modules/**",
+            "knowledge/graph/edges.yaml",
+            "knowledge/graph/entities-index.yaml",
+        ],
+        subtask_prompt: [
+            "B3: Generate AI proposals for the business knowledge graph ONLY under knowledge/bootstrap/staging/**.",
+            "Read knowledge/bootstrap/scope.yaml and knowledge/bootstrap/inventory.json first.",
+            "If scope.yaml has update_mode: incremental (or status.yaml update_mode: incremental), treat this as a narrow incremental update:",
+            "- Prefer seed_features / seed_services / seed_domains and include_paths only; do not re-propose the entire monorepo.",
+            "- Do not invent entities outside the incremental scope; note skipped inventory candidates in coverage-notes.md.",
+            "Create domain/service/module drafts with meta.yaml + overview.md (and interfaces/dependencies/pitfalls when evidence exists).",
+            "Write staging/edges.proposed.yaml and optional staging/features-links.proposed/<F-id>.yaml for seed features.",
+            "Write staging/coverage-notes.md explaining which inventory candidates were covered or skipped.",
+            "Every entity/edge MUST include evidence paths. confidence may be inferred|proposed only — NEVER asserted.",
+            "Do not invent production API details without file evidence; use unknown/TODO instead.",
+            "Do NOT write knowledge/domains|services formal trees or graph indexes — promotion is a later node.",
+            "Stay within writeSet.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildKgBootstrapValidateNode(sources) {
+    const script = buildKgBootstrapInlineNodeScript([
+        "const fs=require('fs');",
+        "const path=require('path');",
+        "const staging=path.join(process.cwd(),'knowledge','bootstrap','staging');",
+        "if(!fs.existsSync(staging)){console.error('missing staging');process.exit(1);}",
+        "function walk(dir,acc=[]){if(!fs.existsSync(dir))return acc;for(const ent of fs.readdirSync(dir,{withFileTypes:true})){const p=path.join(dir,ent.name);if(ent.isDirectory())walk(p,acc);else acc.push(p);}return acc;}",
+        "const files=walk(staging);",
+        "if(files.length===0){console.error('staging empty');process.exit(1);}",
+        "const ids=new Set(); let failed=false;",
+        "for(const f of files){",
+        "  if(!f.endsWith('meta.yaml')&&!f.endsWith('edges.proposed.yaml')) continue;",
+        "  const text=fs.readFileSync(f,'utf8');",
+        "  if(/confidence:\\s*asserted/i.test(text)&&f.includes('staging')){console.error('agent must not self-assert: '+f);failed=true;}",
+        "  const m=text.match(/^id:\\s*([A-Za-z0-9_-]+)/m);",
+        "  if(m){ if(ids.has(m[1])){console.error('duplicate id '+m[1]);failed=true;} ids.add(m[1]); }",
+        "}",
+        "const edgesPath=path.join(staging,'edges.proposed.yaml');",
+        "if(!fs.existsSync(edgesPath)){console.error('missing staging/edges.proposed.yaml');failed=true;}",
+        "if(!fs.existsSync(path.join(staging,'coverage-notes.md'))){console.error('missing staging/coverage-notes.md');failed=true;}",
+        "if(failed) process.exit(1);",
+        "console.log('kg-bootstrap validate ok files='+files.length+' ids='+ids.size);",
+    ]);
+    return {
+        id: "kg-bootstrap-validate-shell",
+        depends_on: ["kg-bootstrap-propose-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: ["knowledge/bootstrap/staging/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validate staging proposals: non-empty, edges.proposed + coverage-notes present, no self-asserted confidence, unique ids.",
+        subtask_prompt: "B4 deterministic validation of knowledge/bootstrap/staging.",
+        shell: {
+            commands: [script],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [script],
+                finalFullRequired: true,
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+function buildKgBootstrapReviewNode(sources) {
+    return {
+        id: "kg-bootstrap-review-pi",
+        depends_on: ["kg-bootstrap-validate-shell"],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "HIGH",
+        writePolicy: "read-only",
+        allowedPaths: ["knowledge/bootstrap/**", "knowledge/**", "features/**", "docs/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision; human still promotes asserted entities.",
+        subtask_prompt: [
+            "Review staging knowledge-graph proposals for evidence quality, over-claiming, missing inventory coverage, and unsafe edges.",
+            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+            "pass means proposals are ready for human promotion consideration — it does NOT mark entities asserted.",
+            "request-revision if critical entities lack evidence, ids collide conceptually, or formal trees were written outside staging.",
+            "Read-only: do not modify files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildKgBootstrapReviewGateNode(sources) {
+    return {
+        id: "kg-bootstrap-review-gate-shell",
+        depends_on: ["kg-bootstrap-review-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Deterministic gate: exit 0 only when kg-bootstrap-review-pi first verdict line is VERDICT: pass.",
+        subtask_prompt: "Block promote/materialize unless review verdict is pass.",
+        shell: {
+            commands: [],
+            verdictGate: {
+                fromNodeId: "kg-bootstrap-review-pi",
+                accept: ["VERDICT: pass"],
+                label: "kg-bootstrap-review",
+                lineMode: "first-verdict-line",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildKgBootstrapPromoteNode(sources) {
+    const script = buildKgBootstrapInlineNodeScript([
+        "const fs=require('fs');",
+        "const path=require('path');",
+        "const root=process.cwd();",
+        "const staging=path.join(root,'knowledge','bootstrap','staging');",
+        "function copyDir(src,dest){",
+        "  if(!fs.existsSync(src)) return 0;",
+        "  let n=0;",
+        "  fs.mkdirSync(dest,{recursive:true});",
+        "  for(const ent of fs.readdirSync(src,{withFileTypes:true})){",
+        "    const s=path.join(src,ent.name), d=path.join(dest,ent.name);",
+        "    if(ent.isDirectory()) n+=copyDir(s,d);",
+        "    else { if(!fs.existsSync(d)){ fs.mkdirSync(path.dirname(d),{recursive:true}); fs.copyFileSync(s,d); n++; } }",
+        "  }",
+        "  return n;",
+        "}",
+        "let copied=0;",
+        "copied+=copyDir(path.join(staging,'domains'), path.join(root,'knowledge','domains'));",
+        "copied+=copyDir(path.join(staging,'services'), path.join(root,'knowledge','services'));",
+        "copied+=copyDir(path.join(staging,'modules'), path.join(root,'knowledge','modules'));",
+        "const edgesSrc=path.join(staging,'edges.proposed.yaml');",
+        "const edgesManual=path.join(root,'knowledge','graph','edges.manual.yaml');",
+        "if(fs.existsSync(edgesSrc)){ fs.mkdirSync(path.dirname(edgesManual),{recursive:true}); if(!fs.existsSync(edgesManual)) fs.copyFileSync(edgesSrc,edgesManual); }",
+        "const linksDir=path.join(staging,'features-links.proposed');",
+        "if(fs.existsSync(linksDir)){",
+        "  for(const f of fs.readdirSync(linksDir)){",
+        "    if(!f.endsWith('.yaml')&&!f.endsWith('.yml')) continue;",
+        "    const id=f.replace(/\\.ya?ml$/,'');",
+        "    const dest=path.join(root,'features',id,'knowledge-links.yaml');",
+        "    if(!fs.existsSync(path.join(root,'features',id))) continue;",
+        "    if(!fs.existsSync(dest)){ fs.mkdirSync(path.dirname(dest),{recursive:true}); fs.copyFileSync(path.join(linksDir,f),dest); copied++; }",
+        "  }",
+        "}",
+        "console.log('kg-bootstrap promote copied_new_files='+copied+' (existing asserted targets skipped)');",
+    ]);
+    return {
+        id: "kg-bootstrap-promote-shell",
+        depends_on: ["kg-bootstrap-review-gate-shell"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "exclusive",
+        writeSet: [
+            "knowledge/domains/**",
+            "knowledge/services/**",
+            "knowledge/modules/**",
+            "knowledge/graph/edges.manual.yaml",
+            "features/**/knowledge-links.yaml",
+        ],
+        allowedPaths: [
+            "knowledge/bootstrap/staging/**",
+            "knowledge/domains/**",
+            "knowledge/services/**",
+            "knowledge/modules/**",
+            "knowledge/graph/**",
+            "features/**",
+        ],
+        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: {
+            commands: [script],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [script],
+                finalFullRequired: true,
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+function buildKgBootstrapMaterializeNode(sources) {
+    const script = buildKgBootstrapInlineNodeScript([
+        "const fs=require('fs');",
+        "const path=require('path');",
+        "const root=process.cwd();",
+        "const entities=[];",
+        "function walk(dir,acc=[]){if(!fs.existsSync(dir))return acc;for(const ent of fs.readdirSync(dir,{withFileTypes:true})){const p=path.join(dir,ent.name);if(ent.isDirectory())walk(p,acc);else acc.push(p);}return acc;}",
+        "for (const base of ['knowledge/domains','knowledge/services','knowledge/modules']) {",
+        "  for (const f of walk(path.join(root,base))) {",
+        "    if(!f.endsWith('meta.yaml')&&!f.endsWith('.md')) continue;",
+        "    const rel=path.relative(root,f).split(path.sep).join('/');",
+        "    const text=fs.existsSync(f)&&f.endsWith('meta.yaml')?fs.readFileSync(f,'utf8'):'';",
+        "    const id=(text.match(/^id:\\s*([A-Za-z0-9_-]+)/m)||[])[1];",
+        "    const kind=(text.match(/^kind:\\s*([A-Za-z0-9_-]+)/m)||[])[1];",
+        "    if(id) entities.push({kind:kind||'unknown',id,path:rel});",
+        "  }",
+        "}",
+        "const featRoot=path.join(root,'features');",
+        "if(fs.existsSync(featRoot)){",
+        "  for(const name of fs.readdirSync(featRoot)){",
+        "    if(!/^F-/.test(name)) continue;",
+        "    entities.push({kind:'feature',id:name,path:'features/'+name+'/'} );",
+        "    const acc=path.join(featRoot,name,'acceptance.yaml');",
+        "    if(fs.existsSync(acc)) entities.push({kind:'ac-file',id:name+':acceptance',path:'features/'+name+'/acceptance.yaml',feature_id:name});",
+        "  }",
+        "}",
+        "const graphDir=path.join(root,'knowledge','graph');",
+        "fs.mkdirSync(graphDir,{recursive:true});",
+        "const index={schema_version:1,generated_at:new Date().toISOString(),entities};",
+        "fs.writeFileSync(path.join(graphDir,'entities-index.yaml'),'# generated by kg-bootstrap-materialize\\nschema_version: 1\\ngenerated_at: '+index.generated_at+'\\nentities:\\n'+entities.map(e=>'  - kind: '+e.kind+'\\n    id: '+e.id+'\\n    path: '+e.path+'\\n').join(''));",
+        "const manual=path.join(graphDir,'edges.manual.yaml');",
+        "const edgesOut=path.join(graphDir,'edges.yaml');",
+        "if(fs.existsSync(manual)) fs.copyFileSync(manual,edgesOut);",
+        "else fs.writeFileSync(edgesOut,'schema_version: 1\\nupdated_at: '+index.generated_at+'\\nedges: []\\n');",
+        "console.log('materialized entities='+entities.length);",
+    ]);
+    return {
+        id: "kg-bootstrap-materialize-shell",
+        depends_on: ["kg-bootstrap-promote-shell"],
+        role: "closeout",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "exclusive",
+        writeSet: [
+            "knowledge/graph/entities-index.yaml",
+            "knowledge/graph/edges.yaml",
+        ],
+        allowedPaths: ["knowledge/**", "features/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Write knowledge/graph/entities-index.yaml and edges.yaml from formal trees + edges.manual.yaml.",
+        subtask_prompt: "B6 materialize graph indexes for kb-query.",
+        shell: {
+            commands: [script],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [script],
+                finalFullRequired: true,
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+function buildKnowledgeGraphBootstrapHybridDag(sources) {
+    const { taskConfig } = sources;
+    const globalConstraints = [
+        ...taskConfig.hardConstraints,
+        ...(sources.constraintMarkdown
+            ? [`See 执行约束.md in task source (${sources.taskId})`]
+            : []),
+        ...STANDARD_GLOBAL_CONSTRAINTS,
+        "knowledge-graph-bootstrap-dag: AI may write only knowledge/bootstrap/staging/** and runs/** until promote.",
+        "AI must never set confidence: asserted; only human promotion marks formal knowledge.",
+        "Do not modify src/**, testcase/**, or Feature testing verdict/cases via bootstrap.",
+        "Promote must not overwrite existing formal files (merge-new-only).",
+        "Require knowledge/bootstrap/scope.yaml before propose (B0/B1 skeleton).",
+        "Graph indexes are written only by materialize-shell, not by propose-pi.",
+    ];
+    const spec = {
+        version: 2,
+        title: `Knowledge-graph bootstrap DAG: ${taskConfig.title}`,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
+        objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
+        successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
+        globalConstraints,
+        defaults: {
+            ...KG_BOOTSTRAP_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: KG_BOOTSTRAP_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        tasks: [
+            buildKgBootstrapPreflightNode(sources),
+            buildKgBootstrapInventoryNode(sources),
+            buildKgBootstrapProposeNode(sources),
+            buildKgBootstrapValidateNode(sources),
+            buildKgBootstrapReviewNode(sources),
+            buildKgBootstrapReviewGateNode(sources),
+            buildKgBootstrapPromoteNode(sources),
+            buildKgBootstrapMaterializeNode(sources),
+        ],
+    };
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -1037,6 +2229,18 @@ export function buildHybridDagFromTask(sources, options = {}) {
         options.template === "frontend-implementation") {
         return buildFrontendHybridDagFromTask(sources);
     }
+    if (sources.taskConfig.taskKind === "backend-test" ||
+        options.template === "backend-test-dag") {
+        return buildBackendTestHybridDag(sources);
+    }
+    if (sources.taskConfig.taskKind === "knowledge-sync" ||
+        options.template === "knowledge-sync-dag") {
+        return buildKnowledgeSyncHybridDag(sources);
+    }
+    if (sources.taskConfig.taskKind === "knowledge-graph-bootstrap" ||
+        options.template === "knowledge-graph-bootstrap-dag") {
+        return buildKnowledgeGraphBootstrapHybridDag(sources);
+    }
     const standard = buildStandardHybridDagFromTask(sources);
     const template = options.template ?? "standard-dag";
     if (template === "standard-dag")
@@ -1048,6 +2252,21 @@ export function buildHybridDagFromTask(sources, options = {}) {
 function cloneTask(task, patch = {}) {
     return { ...task, ...patch };
 }
+/**
+ * Apply the default read-only Pi retry policy to safe planner/scout/reviewer/
+ * verifier/closeout Pi nodes in the generated DAG. Writers, supervisors,
+ * dynamic, shell, static, and decision-gate nodes are skipped. Idempotent:
+ * never overwrites an explicit retryPolicy a task already declares.
+ */
+function applyDefaultReadOnlyRetryPolicy(spec) {
+    for (const task of spec.tasks) {
+        if (task.retryPolicy !== undefined)
+            continue;
+        if (isSafeReadOnlyPiRetryCandidate(task)) {
+            task.retryPolicy = DEFAULT_READ_ONLY_PI_RETRY_POLICY;
+        }
+    }
+}
 function getTaskOrThrow(spec, id) {
     const task = spec.tasks.find((item) => item.id === id);
     if (!task)
@@ -1135,6 +2354,7 @@ function buildReviewGatedHybridDag(standard, sources) {
     replaceTask(spec, cloneTask(closeout, { depends_on: ["review-gate-shell"] }));
     spec.tasks.splice(spec.tasks.length - 1, 0, buildReviewNode(sources), buildReviewGateNode(sources));
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -1263,6 +2483,7 @@ function buildProcessGateNode(sources) {
             },
             repairArtifactGate: {
                 fromNodeId: "process-supervisor-pi",
+                repairNodeId: repairNodeId(),
             },
             cwd: ".",
             timeoutMs: 60000,
@@ -1405,6 +2626,7 @@ function buildSupervisedHybridDag(standard, sources) {
         ],
     };
     applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    applyDefaultReadOnlyRetryPolicy(spec);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;