@tea-agent/loop-agent 0.44.0-next.10 → 0.44.0-next.11

package/dist/workflows/dag/hybrid/templates/index.js

@@ -0,0 +1,8 @@
+/** DAG hybrid 模板族统一入口。 */
+export { buildAnalyzeInputsNode, buildBackendTestAnalysisContractGateNode, buildBackendTestEnvironmentScoutNode, buildBackendTestExecutionContractGateNode, buildGenerateBackendFunctionalCasesNode, buildEmitBackendCaseManifestNode, buildBackendTestCaseManifestGateNode, buildBackendTestTraceabilityGateNode, buildReviewBackendCasesNode, buildExecuteBackendPytestNode, buildClassifyBackendTestResultNode, buildTestRetrospectNode, buildBackendTestOutcomeGateNode, buildL5MetricsNode, applyBackendTestLayoutToText, buildBackendTestModuleManifestShellCommand, buildBackendTestAnalysisHybridDag, buildBackendTestGapFillDag, buildBackendTestHybridDag, applyBackendTestLayoutToDagSpec, BACKEND_TEST_CASE_MANIFEST_OUTPUT_INSTRUCTIONS, collectBackendTestShellEnvAllowlist, taskAllowsBackendTestReportWrite, BACKEND_TEST_DEFAULTS, BACKEND_TEST_SKILLS_BY_ROLE, applyBackendTestWorkspaceControl } from "./backend-test.js";
+export { KNOWLEDGE_SYNC_DEFAULTS, KNOWLEDGE_SYNC_SKILLS_BY_ROLE, buildMultiPerspectiveReviewAggregateScript, buildMultiPerspectiveReviewNodes, KNOWLEDGE_SYNC_FEATURE_ID_RE, assertSafeKnowledgeSyncFeatureId, resolveKnowledgeSyncFeatureId, knowledgeSyncWriteSet, knowledgeSyncPendingWriteSet, knowledgeSyncPointerWriteSet, knowledgeSyncDraftRelPath, buildKnowledgeSyncCollectNode, buildKnowledgeSyncDraftNode, buildKnowledgeSyncValidateNode, KNOWLEDGE_SYNC_MULTI_REVIEW_PERSPECTIVES, buildKnowledgeSyncMultiReviewNodes, buildKnowledgeSyncApplyNode, buildKnowledgeSyncPointerNode, buildKnowledgeSyncHybridDag } from "./knowledge-sync.js";
+export { KG_BOOTSTRAP_DEFAULTS, KG_BOOTSTRAP_SKILLS_BY_ROLE, buildKgBootstrapInlineNodeScript, buildKgBootstrapPreflightNode, buildKgBootstrapInventoryNode, buildKgBootstrapProposeNode, buildKgBootstrapValidateNode, KG_BOOTSTRAP_MULTI_REVIEW_PERSPECTIVES, buildKgBootstrapMultiReviewNodes, buildKgBootstrapPromoteNode, buildKgBootstrapMaterializeNode, buildKnowledgeGraphBootstrapHybridDag } from "./kg-bootstrap.js";
+export { buildFrontendTestHybridDag, applyFrontendTestLayoutToDagSpec, allowedPathsCoverFrontendTestRoot } from "./frontend-test.js";
+export { buildFrontendMockAssessNode, buildFrontendMockContractGateNode, buildFrontendMockVerifyNode, buildBlockedFrontendMockDag, resolveFrontendMockContextBlock, buildFrontendHybridDagFromTask, loadFrontendDagTemplate, frontendMockStrategyMustBeNotNeeded, frontendImplementationNodeId, resolveFrontendCapabilityContextBlock, resolveFrontendShapeCapsuleGenerationInput, deriveFrontendBehaviorPaths, FRONTEND_NO_STATIC_VERIFICATION_MARKER, chooseFrontendVerifyCommands, resolveFrontendOpenspecGateConfig, filterRelevantOpenspecCandidates, frontendComponentConformanceInstruction, buildFrontendWriterNodeDefaults, pruneFrontendTasksForSplitRequired, pruneFrontendTasksForRisk, pruneFrontendTasksForMicro, buildFrontendSpecCandidateSummaries, openspecCandidateMatchesSource, extractOpenspecSourceTokens } from "./frontend.js";
+export { buildStandardHybridDagFromTask, deriveParallelScoutPaths, implementationNodeId, stampTargetTemplateTransientRetryProfile } from "./standard.js";
+export { commonReadOnlyPaths, commonForbiddenPaths, applyDefaultReadOnlyRetryPolicy, stampGeneratedArtifactBindings, mapTaskComplexity, isFrontendTestPathPattern, replaceSourceSegmentWithTestSegment } from "./shared.js";

package/dist/workflows/dag/hybrid/templates/kg-bootstrap.js

@@ -0,0 +1,449 @@
+import { assertValidDagSpec } from "../../validate.js";
+import { DEFAULT_DAG_EXECUTOR_MODELS, DEFAULT_DAG_OUTPUT_LANGUAGE, parseDagSpec } from "../../types.js";
+import { HYBRID_DEFAULTS, STANDARD_GLOBAL_CONSTRAINTS, buildSourceContextBlock, buildVerifyEvidence, extractObjective, extractSuccessCriteria } from "../sources.js";
+import { buildMultiPerspectiveReviewNodes } from "./knowledge-sync.js";
+import { commonForbiddenPaths, stampGeneratedArtifactBindings, } from "./shared.js";
+export const KG_BOOTSTRAP_DEFAULTS = {
+    ...HYBRID_DEFAULTS,
+    writePolicy: "read-only",
+};
+export 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"],
+};
+export function buildKgBootstrapInlineNodeScript(lines) {
+    return ["node", "-e", JSON.stringify(lines.join(""))].join(" ");
+}
+export 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],
+                commandTimeoutMs: 60_000,
+            }),
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+export 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],
+                commandTimeoutMs: 120_000,
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+export 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"),
+    };
+}
+export 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,
+                commandTimeoutMs: 120_000,
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+export const KG_BOOTSTRAP_MULTI_REVIEW_PERSPECTIVES = [
+    {
+        id: "structure",
+        perspective: "architecture / structure",
+        focus: [
+            "domain/service/module partition vs inventory candidates",
+            "id uniqueness and naming conventions",
+            "edges that create impossible or circular dependencies",
+        ],
+    },
+    {
+        id: "evidence",
+        perspective: "evidence / anti-hallucination",
+        focus: [
+            "every entity/edge has concrete evidence paths",
+            "no confidence: asserted in staging",
+            "no invented APIs or production details without files",
+        ],
+    },
+    {
+        id: "safety",
+        perspective: "write-boundary / promote safety",
+        focus: [
+            "writes stayed in knowledge/bootstrap/staging/** (and runs/**)",
+            "no formal knowledge/domains|services trees or graph indexes written by AI",
+            "incremental scope respected when update_mode: incremental",
+        ],
+    },
+];
+export function buildKgBootstrapMultiReviewNodes(sources) {
+    return buildMultiPerspectiveReviewNodes({
+        sources,
+        dependsOn: ["kg-bootstrap-validate-shell"],
+        nodePrefix: "kg-bootstrap-review-",
+        gateId: "kg-bootstrap-multi-review-gate-shell",
+        gateLabel: "kg-bootstrap multi-perspective review",
+        perspectives: KG_BOOTSTRAP_MULTI_REVIEW_PERSPECTIVES,
+        allowedPaths: [
+            "knowledge/bootstrap/**",
+            "knowledge/**",
+            "features/**",
+            "docs/**",
+        ],
+        sharedBrief: [
+            "Review staging knowledge-graph proposals before promote.",
+            "pass means ready for promote consideration — it does NOT mark entities asserted.",
+            "request-revision if critical entities lack evidence, ids collide, or formal trees were written outside staging.",
+        ],
+    });
+}
+export 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;",
+        "    if(!/^F-[A-Za-z0-9][A-Za-z0-9._-]*\\.ya?ml$/.test(f)){ console.error('invalid feature link proposal filename: '+f); process.exit(1); }",
+        "    const id=f.replace(/\\.ya?ml$/,'');",
+        "    if(id.includes('..')){ console.error('invalid feature link proposal filename: '+f); process.exit(1); }",
+        "    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-multi-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,
+                commandTimeoutMs: 120_000,
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+export 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,
+                commandTimeoutMs: 120_000,
+            }),
+            cwd: ".",
+            timeoutMs: 120000,
+        },
+    };
+}
+export 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.",
+        "Multi-perspective review (structure, evidence, safety) must all VERDICT: pass before promote.",
+    ];
+    const multiReview = buildKgBootstrapMultiReviewNodes(sources);
+    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),
+            ...multiReview,
+            buildKgBootstrapPromoteNode(sources),
+            buildKgBootstrapMaterializeNode(sources),
+        ],
+    };
+    stampGeneratedArtifactBindings(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}