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

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

@@ -773,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.",
     ];
@@ -881,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",
@@ -889,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: ".",
@@ -905,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",
@@ -919,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"),
             },
@@ -1382,6 +1453,18 @@ function buildBackendTestHybridDag(sources) {
         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,
@@ -1403,6 +1486,744 @@ function buildBackendTestHybridDag(sources) {
     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;
+}
 export function buildHybridDagFromTask(sources, options = {}) {
     if (sources.taskConfig.taskKind === "frontend-implementation" ||
         options.template === "frontend-implementation") {
@@ -1412,6 +2233,14 @@ export function buildHybridDagFromTask(sources, options = {}) {
         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")