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

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

@@ -1,4 +1,5 @@
-import { access, readdir, readFile, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { access, readdir, readFile, realpath, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { assertValidDagSpec } from "./validate.js";
@@ -14,6 +15,7 @@ import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { materializeTaskReferenceDocs } from "../../task/source-references.js";
 import { resolveVerifyPreset } from "../../executors/shell-verification.js";
 import { resolveExecutorModelMatrices } from "../../executors/model-routing.js";
+import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "./task-demand-routing.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
 const REFERENCE_DIRECTORY = "references";
@@ -148,6 +150,425 @@ const STANDARD_GLOBAL_CONSTRAINTS = [
     "exclusive implementer nodes must use narrow, concrete writeSet paths; never keep ** or repo root",
     `Replace ${IMPLEMENT_WRITESET_PLACEHOLDER} with concrete paths before executing the implementation writer`,
 ];
+// ---------------------------------------------------------------------------
+// Frontend Mock capability discovery & mode resolution
+// ---------------------------------------------------------------------------
+/** Evidence-based check: does package.json contain a mock-related script? */
+async function packageJsonHasMockScript(repoRoot) {
+    try {
+        const raw = await readFile(path.join(repoRoot, "package.json"), "utf-8");
+        const pkg = JSON.parse(raw);
+        const scripts = pkg.scripts ?? {};
+        const mockScripts = Object.keys(scripts).filter((name) => name === "mock" ||
+            name.startsWith("mock:") ||
+            name.startsWith("dev:mock") ||
+            /mock/i.test(name));
+        const verifyCommands = mockScripts
+            .filter((name) => /(?:test|check|verify|contract)/i.test(name))
+            .map((name) => ({
+            label: `npm run ${name}`,
+            args: ["npm", "run", name],
+            cwd: repoRoot,
+        }));
+        return {
+            hasScript: mockScripts.length > 0,
+            scriptNames: mockScripts,
+            verifyCommands,
+        };
+    }
+    catch {
+        return { hasScript: false, scriptNames: [], verifyCommands: [] };
+    }
+}
+/** Check whether a direct (non-transitive) dependency exists in package.json. */
+async function hasDirectDependency(repoRoot, depName) {
+    try {
+        const raw = await readFile(path.join(repoRoot, "package.json"), "utf-8");
+        const pkg = JSON.parse(raw);
+        const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+        return depName in deps;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check whether handler/fixture/bootstrap files exist for known mock frameworks. */
+async function discoverMockHandlerFiles(repoRoot, serviceRoot) {
+    const exactCandidates = [
+        ...[
+            "src/mocks/handlers.ts",
+            "src/mocks/handlers.js",
+            "src/mocks/browser.ts",
+            "src/mocks/browser.js",
+            "src/mocks/server.ts",
+            "src/mocks/server.js",
+            "mocks/handlers.ts",
+            "mocks/handlers.js",
+            "mocks/browser.ts",
+            "mocks/browser.js",
+        ].map((candidatePath) => ({ framework: "msw", path: candidatePath })),
+        ...["db.json", "mock/db.json", "src/mock/db.json"].map((candidatePath) => ({ framework: "json-server", path: candidatePath })),
+    ];
+    const directoryCandidates = [
+        ...(serviceRoot ? [{ path: serviceRoot }] : []),
+        { framework: "mockjs", path: "src/mock" },
+        { framework: "mockjs", path: "mock" },
+        { framework: "msw", path: "src/mocks" },
+        { framework: "msw", path: "mocks" },
+        { framework: "mirage", path: "src/mirage" },
+        { framework: "mirage", path: "mirage" },
+    ];
+    const foundPaths = new Set();
+    let foundFramework;
+    for (const candidate of exactCandidates) {
+        try {
+            await access(path.join(repoRoot, candidate.path));
+            foundPaths.add(candidate.path);
+            foundFramework ??= candidate.framework;
+        }
+        catch {
+            // Exact candidate does not exist.
+        }
+    }
+    async function collectFiles(directory, relativeDirectory) {
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (foundPaths.size >= 24)
+                return;
+            const absoluteEntry = path.join(directory, entry.name);
+            const relativeEntry = path.posix.join(relativeDirectory.replace(/\\/g, "/"), entry.name);
+            if (entry.isDirectory()) {
+                await collectFiles(absoluteEntry, relativeEntry);
+            }
+            else if (entry.isFile()) {
+                foundPaths.add(relativeEntry);
+            }
+        }
+    }
+    for (const candidate of directoryCandidates) {
+        const before = foundPaths.size;
+        await collectFiles(path.join(repoRoot, candidate.path), candidate.path);
+        if (foundPaths.size > before && candidate.framework) {
+            foundFramework ??= candidate.framework;
+        }
+    }
+    return { framework: foundFramework, paths: [...foundPaths].sort() };
+}
+async function discoverMockBootstrapImports(repoRoot) {
+    const entryCandidates = [
+        "src/main.ts",
+        "src/main.tsx",
+        "src/main.js",
+        "src/main.jsx",
+        "src/index.ts",
+        "src/index.tsx",
+        "src/index.js",
+        "src/index.jsx",
+        "src/setupTests.ts",
+        "src/setupTests.js",
+        "test/setup.ts",
+        "test/setup.js",
+    ];
+    const imports = [];
+    for (const candidate of entryCandidates) {
+        try {
+            const content = await readFile(path.join(repoRoot, candidate), "utf-8");
+            if (/(?:from\s*|import\s*)["'][^"']*(?:mock|msw|mirage)[^"']*["']/i.test(content)) {
+                imports.push(candidate);
+            }
+        }
+        catch {
+            // Candidate entry does not exist or is unreadable.
+        }
+    }
+    return imports;
+}
+/**
+ * Deterministic frontend Mock capability discovery.
+ *
+ * Strong evidence (at least one must be hit to judge "present"):
+ * 1. package.json mock script + corresponding config/entry
+ * 2. Direct dependency (MSW, Mock.js, Mirage, json-server, Vite Mock plugin) + handler files
+ * 3. Application bootstrap imports project mock files
+ * 4. Project specs explicitly define mock service root, handler dir, and startup method
+ *
+ * Anti-evidence (cannot alone judge "present"):
+ * - lockfile-only or transitive dependency
+ * - test variable named "mock"
+ * - fixtures without service registration
+ * - neighboring project mock services
+ * - model-directory-name guessing
+ */
+export async function discoverFrontendMockCapability(repoRoot, taskConfig) {
+    const safetyViolation = await frontendMockServiceRootSafetyViolation(repoRoot, taskConfig);
+    if (safetyViolation) {
+        return {
+            status: "ambiguous",
+            serviceRoot: taskConfig.frontendMock?.serviceRoot,
+            safetyViolation,
+            evidencePaths: [],
+            verifyCommands: [],
+            reasons: [safetyViolation],
+        };
+    }
+    const evidencePaths = [];
+    const reasons = [];
+    let framework;
+    let serviceRoot;
+    let strongEvidenceCount = 0;
+    let ambiguousSignals = 0;
+    // 1. Check package.json mock scripts
+    const scriptResult = await packageJsonHasMockScript(repoRoot);
+    if (scriptResult.hasScript) {
+        reasons.push(`package.json has mock scripts: ${scriptResult.scriptNames.join(", ")}`);
+        evidencePaths.push("package.json");
+        // A script alone is not strong evidence unless we also find config/entry
+    }
+    // 2. Check for direct mock framework dependencies
+    const mockDeps = ["msw", "mockjs", "miragejs", "json-server", "vite-plugin-mock"];
+    const foundDeps = [];
+    for (const dep of mockDeps) {
+        if (await hasDirectDependency(repoRoot, dep)) {
+            foundDeps.push(dep);
+            evidencePaths.push(`package.json (${dep})`);
+        }
+    }
+    // 3. Check for handler/fixture/bootstrap files
+    const serviceRootHint = taskConfig.frontendMock?.serviceRoot;
+    const handlerResult = await discoverMockHandlerFiles(repoRoot, serviceRootHint);
+    const bootstrapImports = await discoverMockBootstrapImports(repoRoot);
+    if (handlerResult.framework) {
+        framework = handlerResult.framework;
+    }
+    if (handlerResult.paths.length > 0) {
+        evidencePaths.push(...handlerResult.paths);
+        reasons.push(`Mock handler/fixture paths found: ${handlerResult.paths.join(", ")}`);
+    }
+    if (bootstrapImports.length > 0) {
+        evidencePaths.push(...bootstrapImports);
+        reasons.push(`Application/test bootstrap imports Mock code: ${bootstrapImports.join(", ")}`);
+    }
+    // Evaluate strong evidence
+    // Case: direct dep + handler files
+    if (foundDeps.length > 0 && handlerResult.paths.length > 0) {
+        strongEvidenceCount++;
+        reasons.push(`Direct mock dependency (${foundDeps.join(", ")}) with handler files`);
+    }
+    // Case: mock script in package.json + corresponding config/entry
+    if (scriptResult.hasScript && handlerResult.paths.length > 0) {
+        strongEvidenceCount++;
+        reasons.push("Mock scripts and handler files both present");
+    }
+    if (bootstrapImports.length > 0 && handlerResult.paths.length > 0) {
+        strongEvidenceCount++;
+        reasons.push("Application/test bootstrap and project Mock files both present");
+    }
+    // Case: project specs define mock service root
+    if (taskConfig.frontendMock?.serviceRoot && handlerResult.paths.length > 0) {
+        strongEvidenceCount++;
+        serviceRoot = taskConfig.frontendMock.serviceRoot;
+        reasons.push(`task config specifies serviceRoot=${serviceRoot}`);
+    }
+    // Handle ambiguous: some signals but not enough for "present"
+    if (strongEvidenceCount === 0 &&
+        (foundDeps.length > 0 ||
+            scriptResult.hasScript ||
+            handlerResult.paths.length > 0 ||
+            bootstrapImports.length > 0)) {
+        ambiguousSignals++;
+        if (foundDeps.length > 0 && handlerResult.paths.length === 0) {
+            reasons.push(`Mock dependency found (${foundDeps.join(", ")}) but no handler/bootstrap files detected`);
+        }
+        if (scriptResult.hasScript && handlerResult.paths.length === 0 && foundDeps.length === 0) {
+            reasons.push("Mock scripts exist but no handler files or direct mock dependencies found");
+        }
+    }
+    // Build verify commands from task config
+    const configuredVerifyCommands = (taskConfig.frontendMock?.verifyCommands ?? []).map((cmd) => ({
+        label: cmd.label,
+        args: ["bash", "-lc", cmd.command],
+        cwd: repoRoot,
+        timeoutMs: cmd.timeoutMs,
+    }));
+    const verifyCommands = [...configuredVerifyCommands, ...scriptResult.verifyCommands]
+        .filter((command, index, commands) => commands.findIndex((candidate) => candidate.label === command.label) === index);
+    if (strongEvidenceCount > 0) {
+        return {
+            status: "present",
+            framework,
+            serviceRoot: serviceRoot ?? taskConfig.frontendMock?.serviceRoot,
+            evidencePaths,
+            verifyCommands,
+            reasons,
+        };
+    }
+    if (ambiguousSignals > 0) {
+        return {
+            status: "ambiguous",
+            framework,
+            serviceRoot: taskConfig.frontendMock?.serviceRoot,
+            evidencePaths,
+            verifyCommands,
+            reasons,
+        };
+    }
+    return {
+        status: "absent",
+        evidencePaths,
+        verifyCommands,
+        reasons: ["No mock service evidence found in project"],
+    };
+}
+function patternStaticPrefix(pattern) {
+    const normalized = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+    const wildcard = normalized.search(/[?*]/);
+    return (wildcard >= 0 ? normalized.slice(0, wildcard) : normalized).replace(/\/+$/, "");
+}
+function frontendMockServiceRootAllowed(taskConfig) {
+    const serviceRoot = taskConfig.frontendMock?.serviceRoot;
+    if (!serviceRoot)
+        return true;
+    const normalized = serviceRoot.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (normalized === "." ||
+        normalized === ".." ||
+        normalized.startsWith("../") ||
+        path.isAbsolute(serviceRoot) ||
+        /[?*]/.test(normalized)) {
+        return false;
+    }
+    const allowed = taskConfig.allowedPaths.some((allowedPath) => pathMatchesPattern(normalized, allowedPath) ||
+        pathMatchesPattern(`${normalized}/_probe_`, allowedPath));
+    if (!allowed)
+        return false;
+    return !mergeForbiddenPaths(taskConfig).some((forbiddenPath) => {
+        const forbiddenPrefix = patternStaticPrefix(forbiddenPath);
+        return (pathMatchesPattern(normalized, forbiddenPath) ||
+            (forbiddenPrefix.length > 0 &&
+                pathMatchesPattern(forbiddenPrefix, normalized)));
+    });
+}
+async function frontendMockServiceRootSafetyViolation(repoRoot, taskConfig) {
+    const serviceRoot = taskConfig.frontendMock?.serviceRoot;
+    if (!serviceRoot)
+        return undefined;
+    if (!frontendMockServiceRootAllowed(taskConfig)) {
+        return `frontendMock.serviceRoot is outside allowedPaths or overlaps forbiddenPaths: ${serviceRoot}`;
+    }
+    try {
+        const [repoRealPath, serviceRealPath] = await Promise.all([
+            realpath(repoRoot),
+            realpath(path.resolve(repoRoot, serviceRoot)),
+        ]);
+        const relativeRealPath = path.relative(repoRealPath, serviceRealPath);
+        if (relativeRealPath === ".." ||
+            relativeRealPath.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relativeRealPath)) {
+            return `frontendMock.serviceRoot resolves outside the repository: ${serviceRoot}`;
+        }
+        const normalizedRealPath = relativeRealPath.split(path.sep).join("/") || ".";
+        if (!frontendMockServiceRootAllowed({
+            ...taskConfig,
+            frontendMock: {
+                ...(taskConfig.frontendMock ?? { policy: "auto", verifyCommands: [] }),
+                serviceRoot: normalizedRealPath,
+            },
+        })) {
+            return `frontendMock.serviceRoot resolves outside its allowed boundary: ${serviceRoot}`;
+        }
+    }
+    catch (error) {
+        // A missing configured root is capability absence, not a path escape. The
+        // discovery pass below will report it without traversing another location.
+        if (error.code !== "ENOENT") {
+            return `frontendMock.serviceRoot safety could not be verified: ${serviceRoot}`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Heuristic: does the task have interface/async data dependencies?
+ *
+ * Checks (in priority order):
+ * 1. taskConfig.frontendMock.policy === "required"
+ * 2. Requirement references API docs, schemas, endpoints
+ * 3. Acceptance criteria mention requests, async data, or service states
+ * 4. Contract/scout confirmed existing API call chain (not available at generation time)
+ */
+export function hasApiDependency(sources) {
+    if (sources.taskConfig.frontendMock?.policy === "required") {
+        return true;
+    }
+    const requirement = normalizeTaskRequirementText(sources.requirementMarkdown)
+        .replace(/`[^`\n]*`/g, " ");
+    const dependencyPatterns = [
+        /(?:接口文档|接口定义|接口协议|后端接口|服务端接口|接口联调|请求|响应|远程数据|异步数据|数据获取|模拟接口|模拟数据)/,
+        /(?<![A-Za-z0-9_])API(?![A-Za-z0-9_])/i,
+        /\b(?:endpoint|request|response|fetch|axios|schema|mock|backend\s+api|server\s+api)\b/i,
+    ];
+    const negationPatterns = [
+        /(?:不涉及|无需|不需要|不依赖|不调用|不请求|没有|禁止|不得).{0,16}(?:接口|后端|服务端|远程数据|异步数据|API)/i,
+        /\b(?:no|without|does\s+not|do\s+not|must\s+not)\b.{0,24}\b(?:api|endpoint|request|backend|server)\b/i,
+    ];
+    return requirement
+        .split(/[。！？!?；;，,\r\n]+/)
+        .map((clause) => clause.trim())
+        .filter(Boolean)
+        .some((clause) => !negationPatterns.some((pattern) => pattern.test(clause)) &&
+        dependencyPatterns.some((pattern) => pattern.test(clause)));
+}
+/**
+ * Resolve frontend Mock mode from capability seed, task config, and interface dependency analysis.
+ *
+ * Decision matrix (from docs/design/frontend-mock-data-workflow.md):
+ *
+ * | 接口/异步数据依赖 | 既有 Mock 服务 | policy | 结果 |
+ * |---|---|---|---|
+ * | 无 | 任意 | auto | not-required |
+ * | 有 | present | auto | required |
+ * | 有 | present/absent/ambiguous | auto | required (strategy chooses a safe mechanism) |
+ * | 任意 | present | required | required |
+ * | 任意 | absent/ambiguous | required | blocked |
+ * | 任意 | 任意 | disabled | not-required (if spec allows) else blocked |
+ */
+export function resolveFrontendMockMode(capability, taskConfig, hasApiDep) {
+    const policy = taskConfig.frontendMock?.policy ?? "auto";
+    const hasDeterministicMockVerification = capability.verifyCommands.length > 0;
+    if (capability.safetyViolation || !frontendMockServiceRootAllowed(taskConfig)) {
+        return "blocked";
+    }
+    // disabled policy: must respect project mock rules (can't override spec)
+    if (policy === "disabled") {
+        // When disabled but the project spec mandates mock, it's blocked
+        if (capability.status === "present") {
+            // Project has mock service; disabled is an explicit override that still allows not-required
+            return "not-required";
+        }
+        return "not-required";
+    }
+    // required policy
+    if (policy === "required") {
+        if (capability.status === "present" && hasDeterministicMockVerification) {
+            return "required";
+        }
+        return "blocked";
+    }
+    // auto policy
+    if (!hasApiDep) {
+        return "not-required";
+    }
+    // In auto mode, capability discovery is evidence for the strategy node, not
+    // a final mechanism decision. Projects without a native Mock service may use
+    // an existing browser interception harness or a reversible request adapter.
+    // The deterministic strategy gate blocks before the writer when none can be
+    // verified by the DAG's frozen static/behavior entrypoints.
+    return "required";
+}
 function mapTaskComplexity(complexity) {
     if (complexity === "small")
         return "LOW";
@@ -312,6 +733,10 @@ function markdownVerifyCommand(repoRoot, command) {
         label: command,
     };
 }
+function isSupportedMarkdownVerifyCommand(command) {
+    return (/^(npm|pnpm|yarn|bun)\s+(run\s+)?[a-z0-9:_-]+(?:\s.*)?$/i.test(command) ||
+        /^(npx|pnpm\s+exec|yarn\s+exec|bunx)\s+(vitest|jest|playwright|cypress|tsc|eslint)(?:\s.*)?$/i.test(command));
+}
 function extractFrontendVerifyCommandsFromMarkdown(input) {
     if (!input.repoRoot)
         return { staticCommands: [], behaviorCommands: [] };
@@ -328,8 +753,7 @@ function extractFrontendVerifyCommandsFromMarkdown(input) {
         const codeSpanCommands = Array.from(bulletless.matchAll(/`([^`]+)`/g), (match) => match[1].trim());
         const candidates = codeSpanCommands.length > 0 ? codeSpanCommands : [bulletless];
         for (const candidate of candidates) {
-            if (/^(npm|pnpm|yarn|bun)\s+(run\s+)?[a-z0-9:_-]+(?:\s.*)?$/i.test(candidate) ||
-                /^(npx|pnpm\s+exec|yarn\s+exec|bunx)\s+(vitest|jest|playwright|cypress|tsc|eslint)(?:\s.*)?$/i.test(candidate)) {
+            if (isSupportedMarkdownVerifyCommand(candidate)) {
                 commands.add(candidate);
             }
         }
@@ -350,6 +774,26 @@ function extractFrontendVerifyCommandsFromMarkdown(input) {
     }
     return { staticCommands, behaviorCommands };
 }
+function extractFrontendMockVerifyCommandsFromMarkdown(input) {
+    const commands = [];
+    const markdown = [
+        input.requirementMarkdown,
+        input.constraintMarkdown ?? "",
+    ].join("\n");
+    for (const line of markdown.split(/\r?\n/)) {
+        if (!/(?:mock|模拟服务|接口桩)/i.test(line))
+            continue;
+        for (const match of line.matchAll(/`([^`]+)`/g)) {
+            const commandText = match[1].trim();
+            if (!isSupportedMarkdownVerifyCommand(commandText))
+                continue;
+            const command = markdownVerifyCommand(input.repoRoot, commandText);
+            if (command)
+                commands.push(command);
+        }
+    }
+    return commands.filter((command, index, all) => all.findIndex((candidate) => candidate.args.join("\0") === command.args.join("\0")) === index);
+}
 function chooseFrontendVerifyCommands(input) {
     if (input.parsedCommands.length > 0) {
         return { commands: input.parsedCommands, commandSource: "inline" };
@@ -411,6 +855,39 @@ function toTaskRelativeSourcePath(sources, absolutePath) {
         .relative(sources.taskDir, absolutePath)
         .replaceAll(path.sep, "/");
 }
+function extractExplicitRequirementIds(...markdownInputs) {
+    const ids = [];
+    const seen = new Set();
+    for (const markdown of markdownInputs) {
+        if (!markdown)
+            continue;
+        for (const match of markdown.matchAll(/\b(?:REQ|BR|AC)-[A-Z0-9]+(?:-[A-Z0-9]+)*\b/gi)) {
+            const id = match[0].toUpperCase();
+            if (!seen.has(id)) {
+                seen.add(id);
+                ids.push(id);
+            }
+        }
+    }
+    return ids;
+}
+function buildDagSourceBinding(sources) {
+    const sourceEntries = [
+        { kind: "requirement", path: sources.requirementPath, markdown: sources.requirementMarkdown },
+        ...(sources.constraintMarkdown ? [{ kind: "constraint", path: sources.constraintPath, markdown: sources.constraintMarkdown }] : []),
+        ...(sources.referenceDocuments ?? []).map((reference) => ({ kind: "reference", path: reference.path, markdown: reference.markdown })),
+    ];
+    return {
+        schemaVersion: 1,
+        taskId: sources.taskId,
+        sources: sourceEntries.map((source) => ({
+            kind: source.kind,
+            path: toTaskRelativeSourcePath(sources, source.path),
+            sha256: createHash("sha256").update(source.markdown, "utf8").digest("hex"),
+        })),
+        requirementIds: extractExplicitRequirementIds(sources.requirementMarkdown, sources.constraintMarkdown, ...(sources.referenceDocuments ?? []).map((reference) => reference.markdown)),
+    };
+}
 function buildSourceContextBlock(sources) {
     const requirementRef = toTaskRelativeSourcePath(sources, sources.requirementPath);
     const requirementExcerpt = excerptMarkdown(sources.requirementMarkdown, {
@@ -535,7 +1012,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
     catch (error) {
         throw new Error(`failed to load verification commands for task "${taskId}": ${error instanceof Error ? error.message : String(error)}`);
     }
-    return {
+    const sources = {
         taskId,
         repoRoot,
         taskDir: paths.taskDir,
@@ -551,6 +1028,26 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         verifyCommands,
         sddEmbeddedSkills: await probeRepoLocalSddSkills(repoRoot),
     };
+    return sources;
+}
+async function prepareFrontendMockSources(sources) {
+    const repoRoot = sources.repoRoot ?? process.cwd();
+    const capability = await discoverFrontendMockCapability(repoRoot, sources.taskConfig);
+    const sourceMockVerifyCommands = extractFrontendMockVerifyCommandsFromMarkdown({
+        repoRoot,
+        requirementMarkdown: sources.requirementMarkdown,
+        constraintMarkdown: sources.constraintMarkdown,
+    });
+    for (const command of sourceMockVerifyCommands) {
+        if (!capability.verifyCommands.some((existing) => existing.args.join("\0") === command.args.join("\0"))) {
+            capability.verifyCommands.push(command);
+        }
+    }
+    return {
+        ...sources,
+        frontendMockCapability: capability,
+        frontendMockMode: resolveFrontendMockMode(capability, sources.taskConfig, hasApiDependency(sources)),
+    };
 }
 function mergeFinalVerifyCommands(repoRoot, taskConfig, adapterCommands) {
     const taskCommands = taskConfig.verifyCommands.map((command) => ({
@@ -758,54 +1255,167 @@ export function buildStandardHybridDagFromTask(sources) {
     assertValidDagSpec(spec);
     return spec;
 }
-function buildFrontendHybridDagFromTask(sources) {
+function buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, fixedVerificationContext, readOnlyPaths, forbiddenPaths) {
+    return {
+        id: "frontend-mock-assess-pi",
+        depends_on: ["frontend-contract-pi", "frontend-scout-pi"],
+        role: "planner",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: readOnlyPaths,
+        forbiddenPaths,
+        skills: FRONTEND_IMPLEMENTATION_SKILLS,
+        outputContract: "Plain Markdown whose first non-empty line is MOCK_STRATEGY: native|browser-intercept|request-adapter|not-needed|blocked, followed by Mock Decision, API Contract Evidence, Specification Evidence, Service Evidence, Backend Readiness, Selection Evidence, Endpoint / Fixture Matrix, Activation, Target Files, Production Safety, Verification Plan, Real Integration Gap, and Blocking Issues. No file writes.",
+        subtask_prompt: [
+            "Perform read-only Mock assessment and select one safe frontend data strategy.",
+            "The first non-empty line must be exactly one of: MOCK_STRATEGY: native, MOCK_STRATEGY: browser-intercept, MOCK_STRATEGY: request-adapter, MOCK_STRATEGY: not-needed, or MOCK_STRATEGY: blocked.",
+            "Prefer an existing native Mock facility. Use browser-intercept only with an existing browser/e2e harness. When no Mock exists but the API layer is writable, use request-adapter by adding a minimal reversible adapter/DI seam within the approved writeSet; the real adapter must remain the production default.",
+            "Select not-needed only with positive evidence that no remote API is involved, a stable real backend will be exercised, or existing fixtures already cover the contract without changes. not-needed still requires the fixed behavior entrypoint to exercise applicable real or no-remote behavior verification. When configured policy is required, not-needed is forbidden.",
+            "Configured policy disabled requests no Mock but cannot override project specifications; if an actually-read project rule requires Mock, select blocked.",
+            "",
+            "## Required Output Sections:",
+            "- Mock Decision: required | not-required | blocked (with reasoning)",
+            "- API Contract Evidence and Specification Evidence: actual Mock/API/schema specs read (paths + excerpts)",
+            "- Service Evidence: detected Mock framework, service root, handler/fixture/bootstrap paths",
+            "- Backend Readiness and Selection Evidence: why the selected mechanism is available and appropriate",
+            "- Endpoint / Fixture Matrix: method/path, source, request, success, empty, error, permission, consumer, fixture/evidence",
+            "- Activation and Target Files: explicit dev/test activation and authorized implementation paths",
+            "- Production Safety: how Mock stays off and the real request remains default",
+            "- Verification Plan: map the strategy to the fixed entrypoints below; do not propose replacement shell commands",
+            "- Real Integration Gap: what remains unproved until the real backend is ready",
+            "- Blocking Issues: any spec gaps, path violations, missing verify commands, or conflicts",
+            "",
+            "## Rules:",
+            "- Read project Mock/API/schema specifications before making any judgment.",
+            "- Do not infer Mock service from lockfile-only or transitive dependency evidence.",
+            "- Output MOCK_STRATEGY: blocked if capability evidence conflicts, contract fields are missing/conflicting, paths or dependencies are unauthorized, specs were not actually read, sources conflict, production-default-off cannot be proven, the API layer is not writable for a new adapter, or the frozen entrypoints cannot verify the selected strategy.",
+            "- Never comment out or replace the real request with inline data, hard-code Mock enablement, import test mocks from a production entrypoint, invent API fields, or place secrets/real user data in fixtures.",
+            "- Mock-backed behavior evidence proves the documented frontend contract only; it never proves real API integration.",
+            "",
+            "Read-only: do not modify repository files.",
+            fixedVerificationContext,
+            sourceContext,
+            mockContextBlock,
+        ].join("\n\n"),
+    };
+}
+function buildFrontendMockContractGateNode(mockMode, configuredPolicy, readOnlyPaths, forbiddenPaths) {
+    // A generation-time blocked decision is a hard fail-closed contract. Keep a
+    // syntactically valid, impossible verdict so the shell gate can never pass
+    // regardless of what the assessment model emits.
+    const acceptedStrategies = mockMode === "blocked"
+        ? ["MOCK_STRATEGY: __blocked__"]
+        : configuredPolicy === "disabled"
+            ? ["MOCK_STRATEGY: not-needed"]
+            : [
+                "MOCK_STRATEGY: native",
+                "MOCK_STRATEGY: browser-intercept",
+                "MOCK_STRATEGY: request-adapter",
+                ...(configuredPolicy !== "required"
+                    ? ["MOCK_STRATEGY: not-needed"]
+                    : []),
+            ];
+    return {
+        id: "frontend-mock-contract-gate-shell",
+        depends_on: ["frontend-mock-assess-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: readOnlyPaths,
+        forbiddenPaths,
+        outputContract: "Deterministic Mock contract gate: exit 0 only when frontend-mock-assess-pi selects an allowed non-blocked strategy. Does not authorize code writes.",
+        subtask_prompt: "Deterministic gate: block plan/design/implement when frontend-mock-assess-pi selected blocked, selected not-needed under explicit policy=required, or emitted malformed output. Failure route: ContractMismatch.",
+        shell: {
+            commands: [],
+            verdictGate: {
+                fromNodeId: "frontend-mock-assess-pi",
+                accept: acceptedStrategies,
+                label: "frontend mock contract",
+                lineMode: "first-non-empty",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
+function buildFrontendMockVerifyNode(sources, implementId, readOnlyPaths, forbiddenPaths) {
+    const capability = sources.frontendMockCapability;
+    const taskConfig = sources.taskConfig;
+    // Collect verify commands from task config, capability seed, and manifest
+    const verifyCommands = [];
+    // 1. Task config commands (highest priority)
+    for (const cmd of taskConfig.frontendMock?.verifyCommands ?? []) {
+        verifyCommands.push({
+            label: cmd.label,
+            args: ["bash", "-lc", cmd.command],
+            cwd: sources.repoRoot ?? ".",
+            timeoutMs: cmd.timeoutMs,
+        });
+    }
+    // 2. Capability seed commands (from discovery)
+    if (capability) {
+        for (const cmd of capability.verifyCommands) {
+            if (!verifyCommands.some((existing) => existing.label === cmd.label)) {
+                verifyCommands.push(cmd);
+            }
+        }
+    }
+    // Fail closed: no commands = no verify shell
+    const commands = verifyCommands.length > 0
+        ? buildVerifyShellCommands({
+            repoRoot: sources.repoRoot ?? ".",
+            commands: verifyCommands,
+            fallbackCommands: [],
+        })
+        : [];
+    return {
+        id: "frontend-mock-verify-shell",
+        depends_on: [implementId],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: readOnlyPaths,
+        forbiddenPaths,
+        outputContract: "Archived shell stdout/stderr with exit codes for deterministic Mock-specific verification; no worktree writes.",
+        subtask_prompt: "Run deterministic Mock-specific verification (handler loading, endpoint matrix, fixture consumption, production boundary). Commands are frozen from generation-time trusted sources only.",
+        shell: {
+            commands,
+            verifyEvidence: buildVerifyEvidence({
+                phase: "intermediate",
+                quota: "full",
+                commandSource: commands.length > 0 ? "inline" : "adapter",
+                commands: verifyCommands.length > 0 ? verifyCommands : undefined,
+                fallbackCommands: [],
+            }),
+            cwd: ".",
+            timeoutMs: 300000,
+        },
+    };
+}
+function buildBlockedFrontendMockDag(sources, sourceContext, readOnlyPaths, forbiddenPaths, globalConstraints) {
     const { taskConfig } = sources;
-    const forbiddenPaths = mergeForbiddenPaths(taskConfig);
-    const implementPaths = resolveImplementPaths(taskConfig);
-    const implementId = frontendImplementationNodeId();
-    const sourceContext = buildSourceContextBlock(sources);
-    const strategy = resolveDagVerifyStrategy(taskConfig);
-    const readOnlyPaths = taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"];
-    const behaviorPaths = deriveFrontendBehaviorPaths(taskConfig);
-    const globalConstraints = [
-        ...taskConfig.hardConstraints,
-        ...(sources.constraintMarkdown
-            ? [`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 complete deterministic static verification and behavior verification before final review.",
-        "frontend review must block closeout unless review verdict is exactly VERDICT: pass.",
-    ];
-    const staticFallbackCommands = ["npm run typecheck", "npm run build"];
-    const behaviorFallbackCommands = ["npm test"];
-    const parsedFrontendVerifyCommands = extractFrontendVerifyCommandsFromMarkdown({
-        repoRoot: sources.repoRoot,
-        requirementMarkdown: sources.requirementMarkdown,
-        constraintMarkdown: sources.constraintMarkdown,
-    });
-    const staticVerifyCommands = chooseFrontendVerifyCommands({
-        parsedCommands: parsedFrontendVerifyCommands.staticCommands,
-        adapterCommands: sources.verifyCommands?.intermediate,
-    });
-    const behaviorVerifyCommands = chooseFrontendVerifyCommands({
-        parsedCommands: parsedFrontendVerifyCommands.behaviorCommands,
-        adapterCommands: sources.verifyCommands?.final,
-    });
+    const mockContextBlock = resolveFrontendMockContextBlock(sources);
     const spec = {
         version: 3,
-        title: `Frontend implementation DAG: ${taskConfig.title}`,
+        title: `Frontend implementation DAG (BLOCKED Mock): ${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,
+        globalConstraints: [
+            ...globalConstraints,
+            "Mock contract is BLOCKED: writer nodes must not be reachable. Resolve blocking issues and re-generate DAG.",
+            "Do not execute any write, verify, or closeout nodes. The DAG ends at the Mock contract gate.",
+        ],
         defaults: {
             ...FRONTEND_DEFAULTS,
             contextProfile: taskConfig.contextProfile,
         },
         skillsByRole: FRONTEND_SKILLS_BY_ROLE,
         executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
-        verifyStrategy: resolveDagVerifyStrategy(taskConfig),
         tasks: [
             {
                 id: "frontend-contract-pi",
@@ -843,60 +1453,376 @@ function buildFrontendHybridDagFromTask(sources) {
                     sourceContext,
                 ].join("\n\n"),
             },
-            {
-                id: "frontend-plan-pi",
-                depends_on: ["frontend-scout-pi"],
-                role: "planner",
-                executor: "pi",
-                complexity: "MED",
-                writePolicy: "read-only",
-                allowedPaths: readOnlyPaths,
-                forbiddenPaths,
-                skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown implementation plan with Implementation Steps, Target Files, UI State Handling, Styling / Component Strategy, Interaction Notes, Dependency Policy, Verification Plan, and Residual Risks. No file writes.",
-                subtask_prompt: [
-                    "Based on frontend-contract-pi and frontend-scout-pi, return a minimal frontend implementation plan.",
-                    "Include ordered steps, target files, UI state handling, styling/component strategy, interaction notes, dependency policy, and deterministic verification commands.",
-                    "Read-only: do not modify code, docs, artifacts, or repository files.",
-                    sourceContext,
-                ].join("\n\n"),
-            },
-            {
-                id: "frontend-design-gate-pi",
-                depends_on: ["frontend-plan-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, Required Plan Corrections, and Checked Items. No file writes.",
-                subtask_prompt: [
-                    "Audit the frontend plan before implementation.",
-                    "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "Request revision for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, or missing deterministic verification commands.",
-                    "Read-only: do not modify repository files.",
-                    sourceContext,
-                ].join("\n\n"),
-            },
-            {
-                id: "frontend-design-gate-shell",
-                depends_on: ["frontend-design-gate-pi"],
+            buildFrontendMockAssessNode(sources, sourceContext, mockContextBlock, "No verification entrypoints were materialized because the generation-time Mock contract is blocked.", readOnlyPaths, forbiddenPaths),
+            buildFrontendMockContractGateNode("blocked", taskConfig.frontendMock?.policy ?? "auto", readOnlyPaths, forbiddenPaths),
+        ],
+    };
+    applyDefaultReadOnlyRetryPolicy(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+function resolveFrontendMockContextBlock(sources) {
+    const capability = sources.frontendMockCapability;
+    const mode = sources.frontendMockMode ?? "not-required";
+    if (!capability)
+        return "";
+    const parts = [
+        "## Frontend Mock Context",
+        "",
+        `Configured Policy: ${sources.taskConfig.frontendMock?.policy ?? "auto"}`,
+        `Mock Decision: ${mode}`,
+        `Capability Status: ${capability.status}`,
+    ];
+    if (capability.framework) {
+        parts.push(`Detected Framework: ${capability.framework}`);
+    }
+    if (capability.serviceRoot) {
+        parts.push(`Service Root: ${capability.serviceRoot}`);
+    }
+    if (capability.evidencePaths.length > 0) {
+        parts.push(`Evidence Paths: ${capability.evidencePaths.join(", ")}`);
+    }
+    if (capability.verifyCommands.length > 0) {
+        parts.push(`Frozen Mock Verify Commands: ${capability.verifyCommands
+            .map((command) => command.label)
+            .join(", ")}`);
+    }
+    if (capability.safetyViolation) {
+        parts.push(`Safety Violation: ${capability.safetyViolation}`);
+    }
+    if (capability.reasons.length > 0) {
+        parts.push(`Reasons: ${capability.reasons.join("; ")}`);
+    }
+    if (mode === "required") {
+        parts.push("Mock-backed frontend verification is required. Prefer the detected native service; otherwise the assessment may select an existing browser interception harness or reversible request adapter. Any handler, fixture, adapter, and UI changes stay in the single frontend-implement-pi writeSet.");
+    }
+    if (mode === "not-required") {
+        parts.push("Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed only positively, or select a safe Mock strategy if an API dependency is confirmed.");
+    }
+    if (mode === "blocked") {
+        parts.push("Mock contract is blocked. The DAG must stop before any write node executes.");
+    }
+    return parts.join("\n");
+}
+function buildFrontendHybridDagFromTask(sources) {
+    const { taskConfig } = sources;
+    const mockCapability = sources.frontendMockCapability ?? {
+        status: "absent",
+        evidencePaths: [],
+        verifyCommands: [],
+        reasons: ["Frontend Mock capability was not precomputed; assessment must verify repository evidence."],
+    };
+    const mockMode = sources.frontendMockMode ??
+        resolveFrontendMockMode(mockCapability, taskConfig, hasApiDependency(sources));
+    const frontendSources = {
+        ...sources,
+        frontendMockCapability: mockCapability,
+        frontendMockMode: mockMode,
+    };
+    const forbiddenPaths = mergeForbiddenPaths(taskConfig);
+    const implementPaths = resolveImplementPaths(taskConfig);
+    const implementId = frontendImplementationNodeId();
+    const sourceContext = buildSourceContextBlock(sources);
+    const mockContextBlock = resolveFrontendMockContextBlock(frontendSources);
+    const hasMockVerifyCommands = (taskConfig.frontendMock?.verifyCommands.length ?? 0) > 0 ||
+        mockCapability.verifyCommands.length > 0;
+    const requirementIds = buildDagSourceBinding(sources).requirementIds;
+    const requirementCoverageInstruction = requirementIds.length > 0
+        ? `Include a Requirement Coverage section that lists every exact source identifier: ${requirementIds.join(", ")}. Preserve each identifier verbatim and map it to concrete implementation and verification steps.`
+        : "";
+    const strategy = resolveDagVerifyStrategy(taskConfig);
+    const readOnlyPaths = taskConfig.allowedPaths.length > 0 ? taskConfig.allowedPaths : ["**"];
+    const behaviorPaths = deriveFrontendBehaviorPaths(taskConfig);
+    const globalConstraints = [
+        ...taskConfig.hardConstraints,
+        ...(sources.constraintMarkdown
+            ? [`See 执行约束.md in task source (${sources.taskId})`]
+            : []),
+        ...STANDARD_GLOBAL_CONSTRAINTS,
+        "Frontend implementation DAGs must pass the final design verdict gate before any write node executes; the first design gate also accepts request-revision for plan revision only.",
+        "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 planning must consume the read-only Mock assessment strategy produced after scouting; MOCK_STRATEGY: blocked must not pass the deterministic Mock contract gate.",
+        "Mock implementations must preserve the real request path as the default, require explicit test/dev activation, and never rely on commenting out the real request.",
+        "Mock-backed behavior evidence proves only the documented frontend contract, never real API integration.",
+        "frontend-implementation DAGs must complete deterministic static verification and behavior verification before final review.",
+        "frontend review must block closeout unless review verdict is exactly VERDICT: pass.",
+    ];
+    // Guard: blocked mode — generate assessment-only DAG with no writer reachable
+    if (mockMode === "blocked") {
+        return buildBlockedFrontendMockDag(frontendSources, sourceContext, readOnlyPaths, forbiddenPaths, globalConstraints);
+    }
+    const staticFallbackCommands = ["npm run typecheck", "npm run build"];
+    const behaviorFallbackCommands = ["npm test"];
+    const parsedFrontendVerifyCommands = extractFrontendVerifyCommandsFromMarkdown({
+        repoRoot: sources.repoRoot,
+        requirementMarkdown: sources.requirementMarkdown,
+        constraintMarkdown: sources.constraintMarkdown,
+    });
+    const staticVerifyCommands = chooseFrontendVerifyCommands({
+        parsedCommands: parsedFrontendVerifyCommands.staticCommands,
+        adapterCommands: sources.verifyCommands?.intermediate,
+    });
+    const behaviorVerifyCommands = chooseFrontendVerifyCommands({
+        parsedCommands: parsedFrontendVerifyCommands.behaviorCommands,
+        adapterCommands: sources.verifyCommands?.final,
+    });
+    const staticShellCommands = buildVerifyShellCommands({
+        repoRoot: sources.repoRoot,
+        commands: staticVerifyCommands.commands,
+        fallbackCommands: staticFallbackCommands,
+    });
+    const behaviorShellCommands = buildVerifyShellCommands({
+        repoRoot: sources.repoRoot,
+        commands: behaviorVerifyCommands.commands,
+        fallbackCommands: behaviorFallbackCommands,
+    });
+    const staticVerifyEvidence = buildVerifyEvidence({
+        phase: "intermediate",
+        quota: strategy.intermediateQuota ?? "full",
+        commandSource: staticVerifyCommands.commandSource,
+        commands: staticVerifyCommands.commands,
+        fallbackCommands: staticFallbackCommands,
+    });
+    const behaviorVerifyEvidence = buildVerifyEvidence({
+        phase: "final",
+        quota: "full",
+        commandSource: behaviorVerifyCommands.commandSource,
+        commands: behaviorVerifyCommands.commands,
+        fallbackCommands: behaviorFallbackCommands,
+        finalFullRequired: true,
+    });
+    const fixedVerificationContext = [
+        "## Fixed frontend verification entrypoints",
+        "These shell entrypoints are fixed at DAG generation and are the only commands the static and behavior shell nodes execute. A strategy or plan may add tests behind an existing entrypoint inside writeSet, but must not invent or replace commands or assume subtask_prompt executes a command.",
+        `- Static command source: ${staticVerifyEvidence.commandSource}`,
+        ...staticVerifyEvidence.commandLabels.map((command) => `  - ${JSON.stringify(command)}`),
+        `- Behavior command source: ${behaviorVerifyEvidence.commandSource}`,
+        ...behaviorVerifyEvidence.commandLabels.map((command) => `  - ${JSON.stringify(command)}`),
+    ].join("\n");
+    const spec = {
+        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,
+        defaults: {
+            ...FRONTEND_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: FRONTEND_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        verifyStrategy: resolveDagVerifyStrategy(taskConfig),
+        tasks: [
+            {
+                id: "frontend-contract-pi",
+                depends_on: [],
+                role: "planner",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                skills: FRONTEND_IMPLEMENTATION_SKILLS,
+                outputContract: "Markdown contract with Scope, Non-goals, Acceptance Criteria, UI States, Target Runtime Environment, Risks, and Verification Expectations. No file writes.",
+                subtask_prompt: [
+                    "Read task source and produce a concise frontend implementation contract.",
+                    "Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations.",
+                    "Read-only: do not modify code, docs, artifacts, or repository files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-scout-pi",
+                depends_on: ["frontend-contract-pi"],
+                role: "scout",
+                executor: "pi",
+                complexity: mapTaskComplexity(taskConfig.complexity),
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                skills: FRONTEND_IMPLEMENTATION_SKILLS,
+                outputContract: "Markdown scout report covering frontend stack, routes, components, styling system, existing design conventions, state/data flow, test entry points, reuse opportunities, and risks. No file writes.",
+                subtask_prompt: [
+                    "Inspect frontend code, routing, components, styles, package scripts, and tests.",
+                    "Return code and design observations, existing reuse opportunities, and verification entry points.",
+                    "Read-only: do not modify repository files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            // Mock assessment is always read-only and runs before planning.
+            buildFrontendMockAssessNode(frontendSources, sourceContext, mockContextBlock, fixedVerificationContext, readOnlyPaths, forbiddenPaths),
+            buildFrontendMockContractGateNode(mockMode, taskConfig.frontendMock?.policy ?? "auto", readOnlyPaths, forbiddenPaths),
+            {
+                id: "frontend-plan-pi",
+                depends_on: [
+                    "frontend-contract-pi",
+                    "frontend-scout-pi",
+                    "frontend-mock-assess-pi",
+                    "frontend-mock-contract-gate-shell",
+                ],
+                role: "planner",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                skills: FRONTEND_IMPLEMENTATION_SKILLS,
+                outputContract: "Markdown implementation plan with Requirement Coverage, Implementation Steps, Target Files, UI State Handling, Styling / Component Strategy, Interaction Notes, Mock / API Strategy, Dependency Policy, Verification Plan, Real Integration Gap, and Residual Risks. No file writes.",
+                subtask_prompt: [
+                    "Based on frontend-contract-pi, frontend-scout-pi, and the gated frontend-mock-assess-pi strategy, return a minimal frontend implementation plan.",
+                    "Carry the selected Mock / API strategy, endpoint/fixture mapping, explicit activation, production-default-off rule, verification commands, and Real Integration Gap into the plan.",
+                    "Include ordered steps, target files, UI state handling, styling/component strategy, interaction notes, Mock/API strategy, dependency policy, deterministic verification entrypoints, and residual risks. Use only the fixed entrypoints below; implementation may add tests behind them but cannot replace them.",
+                    requirementCoverageInstruction,
+                    "Read-only: do not modify code, docs, artifacts, or repository files.",
+                    fixedVerificationContext,
+                    sourceContext,
+                    mockContextBlock,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-design-gate-pi",
+                depends_on: ["frontend-plan-pi", "frontend-mock-assess-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, Required Plan Corrections, and Checked Items. No file writes.",
+                subtask_prompt: [
+                    "Audit the frontend plan before implementation.",
+                    "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for the selected strategy. Mock strategies require Mock-backed evidence; not-needed requires applicable real or no-remote behavior evidence.",
+                    "Also request revision for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
+                    "Read-only: do not modify repository files.",
+                    fixedVerificationContext,
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-first-design-gate-shell",
+                depends_on: ["frontend-design-gate-pi"],
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Deterministic 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",
+                    "frontend-mock-assess-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 Requirement Coverage confirmation; request-revision case: complete revised implementation plan with corrections from design findings and Requirement Coverage). No file writes.",
+                subtask_prompt: [
+                    "Consume frontend-plan-pi (original plan) and frontend-design-gate-pi (first design review findings).",
+                    "If the first design gate passed (VERDICT: pass from frontend-design-gate-pi), output exactly:",
+                    "PASS_NO_REVISION_NEEDED",
+                    "The original plan from frontend-plan-pi is confirmed and does not require changes.",
+                    "Then reproduce a complete Requirement Coverage section containing every explicit REQ-/BR-/AC- identifier from the authoritative task sources so this node is the single effective-plan evidence source for the deterministic coverage gate.",
+                    "",
+                    "If the first design gate requested revision (VERDICT: request-revision), produce a complete revised implementation plan that addresses every Required Plan Correction from the design findings.",
+                    "The revised plan must include Requirement Coverage, Implementation Steps, Target Files, UI State Handling, Styling / Component Strategy, Interaction Notes, Mock / API Strategy, Dependency Policy, Verification Plan, Real Integration Gap, and Residual Risks.",
+                    requirementCoverageInstruction,
+                    "Do not turn MOCK_STRATEGY: blocked into an implementable strategy without new repository or contract evidence that resolves every blocker.",
+                    "Read-only: do not modify code, docs, artifacts, or repository files. This node revises the plan only.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            ...(requirementIds.length > 0 ? [{
+                    id: "frontend-requirement-coverage-shell",
+                    depends_on: ["frontend-plan-revision-pi"],
+                    role: "verifier",
+                    executor: "shell",
+                    complexity: "LOW",
+                    writePolicy: "read-only",
+                    allowedPaths: readOnlyPaths,
+                    forbiddenPaths,
+                    outputContract: "Deterministic current-run evidence that the original or revised frontend plan retains every explicit REQ-/BR-/AC- identifier from the bound task sources.",
+                    subtask_prompt: "Block final design review when the current run's plan facts omit any explicit requirement identifier from the authoritative task sources.",
+                    shell: {
+                        commands: [],
+                        requirementCoverageGate: { fromNodeIds: ["frontend-plan-revision-pi"], requiredIds: requirementIds, label: "frontend requirement coverage" },
+                        cwd: ".",
+                        timeoutMs: 60000,
+                    },
+                }] : []),
+            {
+                id: "frontend-final-design-review-pi",
+                depends_on: [
+                    "frontend-plan-revision-pi",
+                    "frontend-plan-pi",
+                    "frontend-design-gate-pi",
+                    "frontend-mock-assess-pi",
+                    ...(requirementIds.length > 0 ? ["frontend-requirement-coverage-shell"] : []),
+                ],
+                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.",
+                    "Recheck the selected Mock / API strategy, contract-to-fixture mapping, authorized paths/dependencies, explicit activation, production-default-off behavior, behavior verification, and Real Integration Gap. MOCK_STRATEGY: blocked cannot receive VERDICT: pass.",
+                    "The frontend requirement coverage gate has verified that every explicit REQ-/BR-/AC- identifier remains present in the current-run plan evidence; review the mapped behavior rather than accepting identifier presence alone.",
+                    "Request revision if any design gap remains, if corrections are incomplete, or if the revised plan introduces new unaddressed issues.",
+                    "Read-only: do not modify repository files.",
+                    fixedVerificationContext,
+                    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,13 +1831,17 @@ 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",
+                    "frontend-plan-pi",
+                    "frontend-mock-assess-pi",
+                ],
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
-                complexity: taskConfig.complexity === "large"
-                    ? "HIGH"
-                    : "MED",
+                complexity: resolveWriterComplexity(taskConfig),
                 writePolicy: "exclusive",
                 writeSet: implementPaths.writeSet,
                 allowedPaths: implementPaths.allowedPaths,
@@ -919,14 +1849,26 @@ 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.",
+                    "Implement only the approved Mock strategy from frontend-mock-assess-pi as carried through the approved plan. Preserve the real request path as the default, require explicit test/dev activation, and never comment out or replace the real request with inline data.",
+                    "The frontend-final-design-review-pi verdict confirmed the plan is ready. Stay within writeSet and preserve unrelated files.",
+                    "For native, browser-intercept, or request-adapter, implement contract-aligned fixtures/states and a dev/test-only activation boundary in this same writer. For not-needed, do not add Mock files or a framework and state the positive reason.",
+                    "Do not write root artifacts/** unless explicitly included in writeSet.",
+                    writerDeliveryContract(taskConfig),
                     sourceContext,
-                ].join("\n\n"),
+                    mockContextBlock,
+                ].filter((value) => Boolean(value)).join("\n\n"),
             },
+            // Optional dedicated Mock verification exists only when trusted commands
+            // were frozen at generation time. Behavior verification remains required.
+            ...(mockMode === "required" && hasMockVerifyCommands
+                ? [buildFrontendMockVerifyNode(frontendSources, implementId, readOnlyPaths, forbiddenPaths)]
+                : []),
             {
                 id: "frontend-static-verify-shell",
-                depends_on: [implementId],
+                depends_on: mockMode === "required" && hasMockVerifyCommands
+                    ? ["frontend-mock-verify-shell"]
+                    : [implementId],
                 role: "verifier",
                 executor: "shell",
                 complexity: "LOW",
@@ -934,20 +1876,10 @@ function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 outputContract: "Archived shell stdout/stderr with exit codes for deterministic static verification; no worktree writes.",
-                subtask_prompt: "Run deterministic static verification for the frontend implementation.",
+                subtask_prompt: "Run deterministic static verification for the frontend implementation, including a production/default-real-path build with Mock activation off when Mock applies. Report only what the commands actually exercise.",
                 shell: {
-                    commands: buildVerifyShellCommands({
-                        repoRoot: sources.repoRoot,
-                        commands: staticVerifyCommands.commands,
-                        fallbackCommands: staticFallbackCommands,
-                    }),
-                    verifyEvidence: buildVerifyEvidence({
-                        phase: "intermediate",
-                        quota: strategy.intermediateQuota ?? "full",
-                        commandSource: staticVerifyCommands.commandSource,
-                        commands: staticVerifyCommands.commands,
-                        fallbackCommands: staticFallbackCommands,
-                    }),
+                    commands: staticShellCommands,
+                    verifyEvidence: staticVerifyEvidence,
                     cwd: ".",
                     timeoutMs: 300000,
                 },
@@ -962,28 +1894,29 @@ function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: behaviorPaths,
                 forbiddenPaths,
                 outputContract: "Archived shell stdout/stderr with exit codes for deterministic behavior verification; no worktree writes.",
-                subtask_prompt: "Run deterministic behavior verification for frontend flows, states, and integration points.",
+                subtask_prompt: "Run the fixed deterministic behavior entrypoints for the selected strategy. For native, browser-intercept, or request-adapter, cover the approved Mock activation and applicable success/loading/empty/error states; for not-needed, exercise applicable real or no-remote behavior. Report only what the commands actually exercise.",
                 shell: {
-                    commands: buildVerifyShellCommands({
-                        repoRoot: sources.repoRoot,
-                        commands: behaviorVerifyCommands.commands,
-                        fallbackCommands: behaviorFallbackCommands,
-                    }),
-                    verifyEvidence: buildVerifyEvidence({
-                        phase: "final",
-                        quota: "full",
-                        commandSource: behaviorVerifyCommands.commandSource,
-                        commands: behaviorVerifyCommands.commands,
-                        fallbackCommands: behaviorFallbackCommands,
-                        finalFullRequired: true,
-                    }),
+                    commands: behaviorShellCommands,
+                    verifyEvidence: behaviorVerifyEvidence,
                     cwd: ".",
                     timeoutMs: 300000,
                 },
             },
             {
                 id: "frontend-review-pi",
-                depends_on: ["frontend-behavior-verify-shell"],
+                depends_on: [
+                    "frontend-static-verify-shell",
+                    "frontend-behavior-verify-shell",
+                    implementId,
+                    "frontend-contract-pi",
+                    "frontend-plan-pi",
+                    "frontend-plan-revision-pi",
+                    "frontend-final-design-review-pi",
+                    "frontend-mock-assess-pi",
+                    ...(mockMode === "required" && hasMockVerifyCommands
+                        ? ["frontend-mock-verify-shell"]
+                        : []),
+                ],
                 role: "reviewer",
                 executor: "pi",
                 complexity: "HIGH",
@@ -996,8 +1929,13 @@ function buildFrontendHybridDagFromTask(sources) {
                     "Review the frontend implementation and verification evidence.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
                     "Any Critical or Important finding must force VERDICT: request-revision.",
+                    "Use the direct contract, original plan, revision/no-op result, and final design review to reconstruct the approved plan and design verdict; do not infer them from the implementation summary.",
+                    "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. Mock strategies require Mock-backed evidence; not-needed requires applicable real or no-remote behavior evidence. Verify that the real request remains the default when Mock activation is absent.",
+                    "Inspect the production/default-real-path static evidence directly and require Mock activation to be off for that check.",
+                    "Distinguish Mock-backed evidence from real API integration evidence and preserve the Real Integration Gap when the backend was not exercised.",
                     "Review implementation quality, behavior/state coverage, verification evidence, and maintainability. Read-only: do not modify files.",
                     sourceContext,
+                    mockContextBlock,
                 ].join("\n\n"),
             },
             {
@@ -1025,7 +1963,16 @@ function buildFrontendHybridDagFromTask(sources) {
             },
             {
                 id: "frontend-closeout-pi",
-                depends_on: ["frontend-review-gate-shell"],
+                depends_on: [
+                    "frontend-review-gate-shell",
+                    "frontend-review-pi",
+                    "frontend-static-verify-shell",
+                    "frontend-behavior-verify-shell",
+                    "frontend-mock-assess-pi",
+                    ...(mockMode === "required" && hasMockVerifyCommands
+                        ? ["frontend-mock-verify-shell"]
+                        : []),
+                ],
                 role: "closeout",
                 executor: "pi",
                 complexity: "MED",
@@ -1035,11 +1982,13 @@ function buildFrontendHybridDagFromTask(sources) {
                     : ["**", "docs/**"],
                 forbiddenPaths,
                 skills: FRONTEND_VERIFICATION_SKILLS,
-                outputContract: "Markdown closeout summary with Changes, Verification Evidence, Review Result, Known Risks, and Follow-up. No file writes.",
+                outputContract: "Markdown closeout summary with Changes, Mock Decision / Strategy / Files / Verification / Production Boundary, Verification Evidence, Review Result, Frontend Status, Real Integration Status, Known Risks, and Follow-up. No file writes.",
                 subtask_prompt: [
-                    "Return a frontend closeout summary covering changes, verification evidence, review result, known risks, and follow-up.",
+                    "Return a frontend closeout summary covering Mock decision/strategy/files/verification/production boundary, changes, verification evidence, review result, known risks, and follow-up.",
+                    `When only Mock-backed evidence passed, state exactly Frontend status: mock-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task to create/run after backend readiness. This follow-up is not auto-created or auto-executed. Never describe Mock evidence as real API integration.`,
                     "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
                     sourceContext,
+                    mockContextBlock,
                 ].join("\n\n"),
             },
         ],
@@ -1062,53 +2011,48 @@ function buildAnalyzeInputsNode(sources) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Structured Markdown extracting core content from source documents. No file writes.",
+        outputContract: "Pure Backend Test Analysis v1 JSON object matching docs/templates/backend-test-analysis.schema.json. No Markdown prose and 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 the task source materials and return exactly one JSON object matching Backend Test Analysis v1.",
+            "Do not wrap it in explanatory prose. A single fenced json block is tolerated, but pure JSON is preferred.",
+            "Copy taskId, requirementPath, requirementSha256, referencePaths, and requirementIds exactly from the DAG source binding shown below.",
+            "Preserve existing AC IDs. Do not invent endpoint methods, paths, fields, errors, boundaries, or business rules; record unknowns in evidenceGaps.",
+            "Use empty arrays for categories not documented. Never include credentials, tokens, private keys, or secret values.",
+            "Required top-level keys: schemaVersion, sourceBinding, acceptanceCriteria, endpoints, dataModels, businessRules, stateTransitions, boundaryConstraints, externalDependencies, risks, evidenceGaps.",
             "Read-only: do not modify code, docs, artifacts, or repository files.",
             buildSourceContextBlock(sources),
         ].join("\n\n"),
     };
 }
+function buildBackendTestAnalysisContractGateNode(sources) {
+    return {
+        id: "backend-test-analysis-contract-shell",
+        depends_on: ["analyze-inputs-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Validated run-owned Backend Test Analysis v1 artifact pointer, schema ID, and SHA-256.",
+        subtask_prompt: "Materialize and validate the backend-test analysis contract under the current DAG run.",
+        shell: {
+            commands: [],
+            jsonArtifactGate: {
+                fromNodeId: "analyze-inputs-pi",
+                schemaId: "backend-test-analysis-v1",
+                artifactName: "backend-test-analysis.json",
+                outputDir: "contracts",
+            },
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+}
 function buildGenerateBackendFunctionalCasesNode(sources) {
     return {
         id: "generate-backend-functional-cases-pi",
-        depends_on: ["analyze-inputs-pi"],
+        depends_on: ["backend-test-analysis-contract-shell"],
         role: "implementer",
         executor: "pi",
         toolProfile: "write",
@@ -1120,7 +2064,7 @@ function buildGenerateBackendFunctionalCasesNode(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.",
+            "Read the validated structured artifact pointer from backend-test-analysis-contract-shell and generate cases only from that JSON contract.", ,
             "",
             "## Output Steps (do in order):",
             "1. First, output a brief summary: how many modules, how many cases planned per module",
@@ -1135,9 +2079,9 @@ function buildGenerateBackendFunctionalCasesNode(sources) {
             "## 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):",
+            "- Boundary conditions: include ONLY if upstream analyze-inputs-pi mentions value ranges, length limits, numeric bounds, or format constraints",
             "- 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",
@@ -1146,279 +2090,1367 @@ function buildGenerateBackendFunctionalCasesNode(sources) {
             "",
             "## Constraints:",
             "- Stay within writeSet: testcase/md/**",
-            "- Do NOT re-read source documents — use the upstream analyze-inputs-pi output only",
+            "- Do NOT re-read source documents or fall back to free-form analysis — use the validated structured artifact only", ,
             "- Do not write root artifacts/**",
         ].join("\n\n"),
     };
 }
-function buildReviewBackendCasesNode(sources) {
+function buildReviewBackendCasesNode(sources) {
+    return {
+        id: "review-backend-cases-pi",
+        depends_on: ["generate-backend-functional-cases-pi", "backend-test-analysis-contract-shell"],
+        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)",
+            "- 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):",
+            "- Boundary coverage: check ONLY if analyze-inputs-pi mentions value ranges, length limits, numeric bounds, or format constraints",
+            "- 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",
+            "- Read the validated backend-test analysis artifact pointer from upstream and use it for AC/source-binding coverage checks", ,
+            "- 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",
+        // test_*.py plus optional helpers/factories under testcase/ (not conftest/config)
+        writeSet: [
+            "testcase/**/test_*.py",
+            "testcase/**/helpers/**",
+            "testcase/**/factories/**",
+        ],
+        // Union task allowedPaths with testcase/** so writeSet stays in scope even when
+        // task.json only lists product paths (e.g. ./src/**). Writes still gated by writeSet.
+        allowedPaths: Array.from(new Set([...commonReadOnlyPaths(sources), "testcase/**"])),
+        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",
+            "- Use @pytest.mark.parametrize for boundary cases when the case defines edge values",
+            "- Use markers: @pytest.mark.positive, @pytest.mark.negative, @pytest.mark.boundary",
+            "",
+            "## Test Data Preparation Rules (MUST follow):",
+            "",
+            "### When Setup is Needed",
+            "Setup phase is REQUIRED only when test cases need pre-existing data:",
+            "- Query/Read APIs: need data to exist before querying",
+            "- Update/Delete APIs: need data to exist before modifying",
+            "- State transition tests: need data in specific state",
+            "",
+            "Setup phase is NOT needed for:",
+            "- Create APIs: testing the creation itself",
+            "- Validation tests: testing input validation with invalid data",
+            "",
+            "### Data Setup Strategy",
+            "When setup is needed:",
+            "1. Prefer function-scoped fixtures for isolation; use module/session scope only when cases explicitly share immutable fixtures",
+            "2. Prefer API-based setup from the upstream analyze-inputs-pi API list and reviewed cases",
+            "3. If a required helper/factory is missing, create NEW files only under testcase/**/helpers/** or testcase/**/factories/**",
+            "",
+            "### Data Construction Priority",
+            "1. API-first: construct data via documented APIs from analyze-inputs-pi / reviewed cases",
+            "2. Reuse existing conftest fixtures when present (read-only)",
+            "3. Direct DB writes are LAST RESORT and only if conftest already exposes a safe test DB fixture with rollback/isolation",
+            "4. If neither API nor safe DB fixture exists, skip the case with an explicit gap note — do NOT invent production DB credentials or write live data",
+            "",
+            "### API Data Construction",
+            "- Prefer the analyze-inputs-pi API Endpoints section and reviewed cases for method/path/fields",
+            "- Chain API calls only when cases document multi-step preconditions",
+            "- Store created resource IDs in fixtures for reuse",
+            "- Do NOT broadly search host route/controller trees for secrets, .env, private keys, or production configs",
+            "- Read host API definitions only when needed to resolve a field name already referenced by reviewed cases; stay out of credential/config paths",
+            "",
+            "### Database Data Construction (restricted)",
+            "- Allowed only via existing conftest test-DB fixtures with transaction rollback or equivalent isolation",
+            "- Never hardcode connection strings, passwords, tokens, or cloud credentials",
+            "- Never target production/shared non-test databases",
+            "- If isolation is unclear, report the gap instead of writing DB rows",
+            "",
+            "## Assertion Rules (MUST follow):",
+            "",
+            "### Positive Path",
+            "MUST assert ALL of the following:",
+            "1. HTTP status code: as defined in API spec (e.g. 200, 201)",
+            "2. Response structure: key fields exist in response body",
+            "3. Specific values: each field equals expected value from test case",
+            "4. Data type: each field is correct type",
+            "",
+            "### Negative Path",
+            "MUST assert ALL of the following:",
+            "1. HTTP status code: as defined in API spec (e.g. 400, 404, 500)",
+            "2. Error code field: field name from API spec (e.g. code, error_code, errcode, ret)",
+            "3. Error message field: field name from API spec (e.g. message, msg, errmsg, error)",
+            "",
+            "### Field Name Resolution",
+            "Field names MUST come from the upstream analyze-inputs-pi output (API Endpoints section) or reviewed cases, NOT guessed. For example:",
+            "- If API spec defines {\"ret\": 0, \"msg\": \"success\"}, assert response.json()['ret'] and response.json()['msg']",
+            "- If API spec defines {\"code\": 4001, \"message\": \"error\"}, assert response.json()['code'] and response.json()['message']",
+            "",
+            "## 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",
+            "- Boundary tests: implement ONLY when cases define value ranges, length limits, or format constraints",
+            "- 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 under writeSet: testcase/**/test_*.py, testcase/**/helpers/**, testcase/**/factories/**",
+            "- Do NOT modify existing framework files (conftest.py, pytest.ini, pyproject.toml, setup.cfg, __init__.py)",
+            "- If a test filename exists, add suffix: test_order.py → test_order_01.py",
+            "- Do NOT re-read source documents — use reviewed cases under testcase/md/ and upstream analyze-inputs-pi output only",
+            "- Read existing conftest.py/pytest.ini to understand conventions, but do NOT modify them",
+        ].join("\n\n"),
+    };
+}
+function buildExecuteBackendPytestNode(sources) {
+    // Keep the target worktree read-only: JUnit is runner-owned evidence under
+    // the current DAG run and moves with active → completed/paused lifecycle.
+    const pytestCommand = [
+        'test -n "${HARNESS_DAG_RUN_DIR:-}" || { echo "missing HARNESS_DAG_RUN_DIR for backend pytest report" >&2; exit 2; }',
+        'REPORT="${HARNESS_DAG_RUN_DIR}/reports/backend-test-junit.xml"',
+        'mkdir -p "$(dirname "${REPORT}")"',
+        'PYTHONDONTWRITEBYTECODE=1 python -m pytest testcase/ -v -p no:cacheprovider --junitxml="${REPORT}"',
+        'STATUS=$?',
+        'printf "JUnit report: %s\\n" "${REPORT}"',
+        'exit "${STATUS}"',
+    ].join("; ");
+    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; JUnit XML is runner-owned evidence at $HARNESS_DAG_RUN_DIR/reports/backend-test-junit.xml. Must not modify worktree files, testcase sources, production code, or assertions.",
+        subtask_prompt: "Run pytest for the backend test suite; write JUnit evidence only under the current HARNESS_DAG_RUN_DIR/reports/.",
+        shell: {
+            commands: [pytestCommand],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [pytestCommand],
+                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 keep the target worktree read-only and write machine-readable results only under the current HARNESS_DAG_RUN_DIR/reports/** (e.g. JUnit XML).",
+        "pytest automation scripts must use test_ filename prefix for pytest discovery.",
+        "generate-backend-pytest-pi may create only new files under testcase/**/test_*.py, testcase/**/helpers/**, and testcase/**/factories/**; modifying conftest.py, pytest.ini, pyproject.toml, or production code 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,
+        // No convergence loop: review gate is fail-closed. request-revision stops
+        // the DAG; regenerate after fixing cases. Controller still keys off
+        // hard-verify-shell, which this template does not include.
+        defaults: {
+            ...BACKEND_TEST_DEFAULTS,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        tasks: [
+            buildAnalyzeInputsNode(sources),
+            buildBackendTestAnalysisContractGateNode(sources),
+            buildGenerateBackendFunctionalCasesNode(sources),
+            buildReviewBackendCasesNode(sources),
+            buildReviewBackendCasesGateNode(sources),
+            buildGenerateBackendPytestNode(sources),
+            buildExecuteBackendPytestNode(sources),
+            buildTestRetrospectNode(sources),
+        ],
+    };
+    applyDefaultReadOnlyRetryPolicy(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+// ---------------------------------------------------------------------------
+// Frontend browser-test RAG DAG template
+// ---------------------------------------------------------------------------
+function buildFrontendTestHybridDag(sources) {
+    const config = sources.taskConfig.frontendTest ?? { maxCasesPerBatch: 20 };
+    const hasFrontendTestWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "testcase/frontend/**" || pattern === "testcase/**" || pattern === "**");
+    const hasReportWriteScope = sources.taskConfig.allowedPaths.some((pattern) => pattern === "docs/test-reports/**" || pattern === "docs/**" || pattern === "**");
+    if (!hasFrontendTestWriteScope || !hasReportWriteScope) {
+        throw new Error('frontend-test requires task.json allowedPaths to include both "testcase/frontend/**" and "docs/test-reports/**" (or explicit containing globs).');
+    }
+    const forbidden = commonForbiddenPaths(sources);
+    const ragWriteSet = ["testcase/frontend/rag/**"];
+    const casesWriteSet = ["testcase/frontend/cases/**"];
+    const evidenceRoot = "testcase/frontend/evidence";
+    const manifestValidation = [
+        "node -e",
+        JSON.stringify([
+            "const fs=require('fs'),path=require('path');",
+            "const file='testcase/frontend/cases/manifest.json'; if(!fs.existsSync(file)) throw new Error('missing '+file);",
+            "const manifest=JSON.parse(fs.readFileSync(file,'utf8')); if(manifest.schemaVersion!==1||!Array.isArray(manifest.cases)) throw new Error('invalid frontend case manifest');",
+            "const dims=new Set(['core','boundary','flow','backend']);",
+            "const seen=new Set(); const seenCasePath=new Set(); const seenEvidenceDir=new Set();",
+            "for(const c of manifest.cases){",
+            " if(!c||typeof c.caseId!=='string'||!/^FE-[A-Za-z0-9][A-Za-z0-9-]*$/.test(c.caseId)||seen.has(c.caseId)) throw new Error('invalid or duplicate caseId');",
+            " seen.add(c.caseId);",
+            " if(typeof c.dimension!=='string'||!dims.has(c.dimension)) throw new Error('invalid dimension');",
+            " if(!Array.isArray(c.acIds)||c.acIds.length===0||c.acIds.some(a=>typeof a!=='string'||!a.trim())) throw new Error('invalid acIds');",
+            " for(const k of ['casePath','evidenceDir']){ const v=c[k]; if(typeof v!=='string'||path.isAbsolute(v)||v.includes('..')) throw new Error('unsafe '+k); }",
+            " if(c.casePath!=='testcase/frontend/cases/'+c.caseId+'.md') throw new Error('casePath must match caseId');",
+            " if(!c.evidenceDir.startsWith('testcase/frontend/evidence/'+c.caseId+'/')) throw new Error('case path escapes frontend test roots');",
+            " if(seenCasePath.has(c.casePath)) throw new Error('duplicate casePath'); seenCasePath.add(c.casePath);",
+            " if(seenEvidenceDir.has(c.evidenceDir)) throw new Error('duplicate evidenceDir'); seenEvidenceDir.add(c.evidenceDir);",
+            "}",
+            "process.stdout.write(JSON.stringify({cases:manifest.cases}));",
+        ].join("")),
+    ].join(" ");
+    const spec = {
+        version: 3,
+        title: `Frontend test DAG: ${sources.taskConfig.title}`,
+        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
+        objective: extractObjective(sources.requirementMarkdown, sources.taskConfig.title),
+        successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
+        globalConstraints: [
+            ...sources.taskConfig.hardConstraints,
+            ...STANDARD_GLOBAL_CONSTRAINTS,
+            "frontend-test-dag generates Markdown cases and browser evidence only; it must not generate pytest or Playwright test source code.",
+            "Each browser case runs serially in a fresh Pi execution boundary. Persist its evidence before starting the next case.",
+            "Use only the declared isolated test environment. Production URLs, real credentials, and unauthorized data are blocked.",
+            "Browser startup for generated cases must be playwright-cli open --browser=chrome --headed <base-url>.",
+            "Token settings are post-case stop thresholds, never a hard provider token cap. Unstarted cases after a threshold are blocked: token-budget-exhausted.",
+        ],
+        defaults: { ...HYBRID_DEFAULTS, writePolicy: "read-only", contextProfile: sources.taskConfig.contextProfile },
+        skillsByRole: {
+            planner: ["loop-agent"], scout: ["playwright-cli"], implementer: ["playwright-cli-case-generator", "playwright-cli", "webapp-testing"], reviewer: ["requesting-code-review"], verifier: ["playwright-cli", "webapp-testing"], closeout: ["loop-agent", "verification-before-completion"],
+        },
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        tasks: [
+            {
+                id: "retrieve-frontend-test-context-pi", depends_on: [], role: "planner", executor: "pi", toolProfile: "write", complexity: "HIGH", writePolicy: "exclusive", writeSet: ragWriteSet, allowedPaths: [...commonReadOnlyPaths(sources), ...ragWriteSet], forbiddenPaths: forbidden,
+                outputContract: "Write testcase/frontend/rag/context.md and coverage-map.md with traceable UI/API/test-environment facts.",
+                subtask_prompt: ["Build the frontend test RAG package.", "Read task source, relevant routes/components/API or Mock facts, existing tests, and execution contract. Write only testcase/frontend/rag/context.md and coverage-map.md.", "Record AC IDs, source paths, routes, states, roles, fixture/data prerequisites, API mapping status, risks, and isolated execution contract. Do not guess unavailable facts.", buildSourceContextBlock(sources)].join("\n\n"),
+            },
+            {
+                id: "generate-frontend-functional-cases-pi", depends_on: ["retrieve-frontend-test-context-pi"], role: "implementer", executor: "pi", toolProfile: "write", complexity: "HIGH", writePolicy: "exclusive", writeSet: casesWriteSet, allowedPaths: [...ragWriteSet, ...casesWriteSet], forbiddenPaths: forbidden,
+                outputContract: "Write executable Markdown frontend cases, index.md, and manifest.json schemaVersion 1; no test source code.",
+                subtask_prompt: ["Use skill playwright-cli-case-generator.", "Read only testcase/frontend/rag/context.md, testcase/frontend/rag/coverage-map.md, and existing testcase/frontend/cases/. Write only testcase/frontend/cases/**.", "Generate Markdown cases, index.md and manifest.json (schemaVersion 1; cases[] with caseId, casePath, dimension, acIds, evidenceDir). IDs use FE-<FEATURE>-<NNN>-<dimension>; dimensions core|boundary|flow|backend.", "Never infer API fields, constraints, SLA, credentials, or unrecorded test data. Do not create pytest or Playwright source. Every browser start command is: playwright-cli open --browser=chrome --headed <base-url>.", "Each case must be independent, declare its session/preconditions/data cleanup, UI assertions, evidence paths under testcase/frontend/evidence/<case-id>/, and mark unsafe/missing dependencies blocked."].join("\n\n"),
+            },
+            {
+                id: "review-frontend-cases-pi", depends_on: ["generate-frontend-functional-cases-pi"], role: "reviewer", executor: "pi", complexity: "HIGH", writePolicy: "read-only", allowedPaths: [...ragWriteSet, ...casesWriteSet], forbiddenPaths: forbidden,
+                outputContract: "First line VERDICT: pass or VERDICT: request-revision, followed by AC-to-case coverage and execution risk findings; no writes.", subtask_prompt: "Review only the RAG package and frontend Markdown cases. Verify traceability, independent execution, safe data/environment handling, manifest correctness, and evidence requirements. The verdict is advisory and does not block case execution.",
+            },
+            {
+                id: "materialize-frontend-case-manifest-shell", depends_on: ["review-frontend-cases-pi"], role: "verifier", executor: "shell", complexity: "LOW", writePolicy: "read-only", allowedPaths: casesWriteSet, forbiddenPaths: forbidden,
+                outputContract: "stdout is exactly JSON { cases: [...] } after deterministic frontend manifest validation.", subtask_prompt: "Validate and materialize the generated frontend case manifest.", shell: { commands: [manifestValidation], cwd: ".", timeoutMs: 120000 },
+            },
+            {
+                id: "execute-frontend-cases-map", depends_on: ["materialize-frontend-case-manifest-shell"], role: "verifier", executor: "static", complexity: "LOW", writePolicy: "none", allowedPaths: [], forbiddenPaths: forbidden,
+                outputContract: "Serial aggregate of case execution summaries, evidence paths, tokens, and token-budget blocked cases.", subtask_prompt: "Expand and execute the validated frontend case manifest serially.", static: { resultMarkdown: "Frontend case map expansion barrier." },
+                dynamicExpansion: { type: "map_agent", workflowNodeId: "execute-frontend-cases-map", itemsFrom: "$.nodes['materialize-frontend-case-manifest-shell'].output.cases", itemName: "case", maxItems: config.maxCasesPerBatch, maxExpandedNodes: config.maxCasesPerBatch, childIdPrefix: "execute-frontend-case", tokenBudget: { maxTokensPerCase: config.maxTokensPerCase, maxTotalTokens: config.maxTotalTokens }, childTask: {
+                        executor: "pi", role: "verifier", skills: ["playwright-cli", "webapp-testing"], toolProfile: "write", complexity: "MED", writePolicy: "exclusive", allowedPaths: ["testcase/frontend/cases/{{case.caseId}}.md", "testcase/frontend/rag/context.md", "testcase/frontend/rag/coverage-map.md", `${evidenceRoot}/{{case.caseId}}/**`], forbiddenPaths: forbidden, writeSet: [`${evidenceRoot}/{{case.caseId}}/**`], outputContract: "Compact JSON <=1200 characters with case status, evidence paths, error summary, and tokens.", subtaskPromptTemplate: ["Execute exactly case {{case.caseId}} from {{case.casePath}} using playwright-cli and webapp-testing. This is a fresh Pi session; do not use /new.", "Use only the declared isolated test environment. If CLI/browser/base URL/credentials/fixture isolation is missing, record blocked rather than installing tools or guessing.", "Use playwright-cli open --browser=chrome --headed <base-url>. Persist execution.md, case-result.json, screenshots/trace/video/logs under {{case.evidenceDir}} before returning.", "A business failed or blocked case is a recorded result, not a node failure. Close the session and return only compact JSON (<=1200 chars): {caseId,status,evidencePaths,errorSummary,tokens}."].join("\n\n")
+                    } },
+            },
+            {
+                id: "review-frontend-execution-pi", depends_on: ["execute-frontend-cases-map"], role: "reviewer", executor: "pi", complexity: "HIGH", writePolicy: "read-only", allowedPaths: ["testcase/frontend/**"], forbiddenPaths: forbidden,
+                outputContract: "Read-only AC-to-case-to-browser-evidence review, including failed, blocked and token-budget-exhausted cases.", subtask_prompt: "Review the frontend case aggregate and on-disk case/evidence artifacts. A passed case requires assertion plus screenshot or equivalent browser evidence; failed/blocked cases require reasons. Do not replace browser evidence with model conclusions.",
+            },
+            {
+                id: "frontend-test-retrospect-pi", depends_on: ["review-frontend-execution-pi"], role: "closeout", executor: "pi", toolProfile: "write", complexity: "MED", writePolicy: "exclusive", writeSet: ["docs/test-reports/**"], allowedPaths: ["testcase/frontend/**", "docs/test-reports/**"], forbiddenPaths: forbidden,
+                outputContract: "Write frontend-test-retrospect-<date>.md with coverage, pass/fail/blocked, risks, findings, and A/B/C/D rating.", subtask_prompt: "Write the frontend test retrospective under docs/test-reports/. Summarize coverage, passed/failed/blocked cases (including token-budget-exhausted), review findings, browser anomalies, residual risks, and A/B/C/D rating. Blocked cases never count as passed.",
+            },
+        ],
+    };
+    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"],
+};
+/**
+ * Deterministic aggregate gate: all listed review nodes must emit VERDICT: pass
+ * (first VERDICT: line in assistantText/stdout). Uses HARNESS_DAG_RUN_DIR JSON artifacts.
+ */
+export function buildMultiPerspectiveReviewAggregateScript(fromNodeIds, label) {
+    if (fromNodeIds.length === 0) {
+        throw new Error("multi-perspective aggregate requires at least one review node id");
+    }
+    const idsLiteral = JSON.stringify([...fromNodeIds]);
+    const labelLiteral = JSON.stringify(label);
+    return [
+        "node",
+        "-e",
+        JSON.stringify([
+            "const fs=require('fs');",
+            "const path=require('path');",
+            `const ids=${idsLiteral};`,
+            `const label=${labelLiteral};`,
+            "const runDir=process.env.HARNESS_DAG_RUN_DIR;",
+            "if(!runDir){ console.error(label+': missing HARNESS_DAG_RUN_DIR'); process.exit(1); }",
+            "function normalize(line){",
+            "  const t=String(line).trim();",
+            "  const m=t.match(/^\\*{1,3}\\s*(VERDICT:[^*]+?)\\s*\\*{1,3}$/);",
+            "  return (m?m[1]:t).trim();",
+            "}",
+            "function firstVerdict(text){",
+            "  for (const line of String(text||'').split(/\\r?\\n/)) {",
+            "    const n=normalize(line);",
+            "    if(/^VERDICT:/.test(n)) return n;",
+            "  }",
+            "  return '';",
+            "}",
+            "const failures=[];",
+            "for (const id of ids) {",
+            "  const file=path.join(runDir, id+'.json');",
+            "  if(!fs.existsSync(file)){ failures.push(id+': missing JSON '+file); continue; }",
+            "  let raw; try { raw=JSON.parse(fs.readFileSync(file,'utf8')); } catch(e){ failures.push(id+': invalid JSON'); continue; }",
+            "  const verdict=firstVerdict(raw.assistantText ?? raw.stdout ?? '');",
+            "  if(verdict!=='VERDICT: pass') failures.push(id+': '+(verdict||'missing VERDICT line'));",
+            "  else console.log(id+': VERDICT: pass');",
+            "}",
+            "if(failures.length){ console.error(label+' blocked:\\n'+failures.join('\\n')); process.exit(1); }",
+            "console.log(label+': all perspectives VERDICT: pass ('+ids.length+')');",
+        ].join("")),
+    ].join(" ");
+}
+function buildMultiPerspectiveReviewNodes(input) {
+    const reviewNodes = input.perspectives.map((p) => ({
+        id: `${input.nodePrefix}${p.id}-pi`,
+        depends_on: [...input.dependsOn],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "HIGH",
+        writePolicy: "read-only",
+        allowedPaths: input.allowedPaths,
+        forbiddenPaths: commonForbiddenPaths(input.sources),
+        outputContract: `Plain Markdown; first non-empty line is VERDICT: pass or VERDICT: request-revision. Perspective: ${p.perspective}. No file writes.`,
+        subtask_prompt: [
+            `You are the **${p.perspective}** reviewer in a multi-perspective review panel.`,
+            "Other perspectives run in parallel; do not assume their conclusions. Stay in your role.",
+            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+            "Any Critical or Important finding in your domain must force VERDICT: request-revision.",
+            "Structure: VERDICT line, then Findings (Critical/Important/Minor), then Checked Items, then Residual Risks.",
+            "Cite concrete paths/ids as evidence. Read-only: do not modify files.",
+            ...input.sharedBrief,
+            "Focus for this perspective:",
+            ...p.focus.map((line) => `- ${line}`),
+            buildSourceContextBlock(input.sources),
+        ].join("\n\n"),
+    }));
+    const reviewIds = reviewNodes.map((n) => n.id);
+    const aggregateScript = buildMultiPerspectiveReviewAggregateScript(reviewIds, input.gateLabel);
+    const gateNode = {
+        id: input.gateId,
+        depends_on: reviewIds,
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(input.sources),
+        forbiddenPaths: commonForbiddenPaths(input.sources),
+        outputContract: `Deterministic multi-perspective gate: exit 0 only when every review node among ${reviewIds.join(", ")} emits VERDICT: pass.`,
+        subtask_prompt: `Aggregate gate for ${input.gateLabel}: all perspectives must pass before downstream apply/promote.`,
+        shell: {
+            commands: [aggregateScript],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [aggregateScript],
+                finalFullRequired: true,
+            }),
+            cwd: ".",
+            timeoutMs: 60000,
+        },
+    };
+    return [...reviewNodes, gateNode];
+}
+/** 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,
+        },
+    };
+}
+const KNOWLEDGE_SYNC_MULTI_REVIEW_PERSPECTIVES = [
+    {
+        id: "qa",
+        perspective: "QA / acceptance",
+        focus: [
+            "acceptanceVerdict and AC coverage vs evidencePointers",
+            "caseIndex completeness and non-invented pass results",
+            "defects registry consistency with open issues",
+        ],
+    },
+    {
+        id: "domain",
+        perspective: "domain / product",
+        focus: [
+            "requirement-delta risk and silent requirement rewrites",
+            "operations[] targets stay under the bound featureId",
+            "business meaning of coverage/matrix changes",
+        ],
+    },
+    {
+        id: "evidence",
+        perspective: "evidence / audit",
+        focus: [
+            "finalVerification authority is shell evidence, not prose",
+            "high-risk ops and gates.requireHumanIfHighRisk",
+            "draft schema fields and pointer-only log policy",
+        ],
+    },
+];
+function buildKnowledgeSyncMultiReviewNodes(sources, featureId) {
+    return buildMultiPerspectiveReviewNodes({
+        sources,
+        dependsOn: ["knowledge-sync-validate-shell"],
+        nodePrefix: "knowledge-sync-review-",
+        gateId: "knowledge-sync-multi-review-gate-shell",
+        gateLabel: "knowledge-sync multi-perspective review",
+        perspectives: KNOWLEDGE_SYNC_MULTI_REVIEW_PERSPECTIVES,
+        allowedPaths: [
+            ...commonReadOnlyPaths(sources),
+            `features/${featureId}/**`,
+            "docs/test-reports/**",
+        ],
+        sharedBrief: [
+            `Bound featureId: ${featureId}. Only review draft/ops for this Feature.`,
+            `Primary draft path: ${knowledgeSyncDraftRelPath(featureId)}.`,
+            "Apply is blocked until all perspectives pass. Do not approve fabricated verification pass.",
+        ],
+    });
+}
+function buildKnowledgeSyncApplyNode(sources, featureId) {
+    const writeSet = knowledgeSyncWriteSet(featureId);
+    const draftPath = knowledgeSyncDraftRelPath(featureId);
+    return {
+        id: "knowledge-sync-apply-pi",
+        depends_on: ["knowledge-sync-multi-review-gate-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 and multi-perspective review gate pass; final verification evidence remains the completion authority.",
+        "Multi-perspective review: QA/acceptance, domain/product, and evidence/audit must each emit VERDICT: pass before apply.",
+        "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 multiReview = buildKnowledgeSyncMultiReviewNodes(sources, featureId);
+    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),
+            ...multiReview,
+            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: "review-backend-cases-pi",
-        depends_on: ["generate-backend-functional-cases-pi"],
-        role: "reviewer",
-        executor: "pi",
-        complexity: "HIGH",
+        id: "kg-bootstrap-preflight-shell",
+        depends_on: [],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
         writePolicy: "read-only",
-        allowedPaths: commonReadOnlyPaths(sources),
+        allowedPaths: ["knowledge/bootstrap/**", "knowledge/graph/**"],
         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"),
+        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 buildReviewBackendCasesGateNode(sources) {
+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: "review-backend-cases-gate-shell",
-        depends_on: ["review-backend-cases-pi"],
+        id: "kg-bootstrap-inventory-shell",
+        depends_on: ["kg-bootstrap-preflight-shell"],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
-        writePolicy: "read-only",
-        allowedPaths: commonReadOnlyPaths(sources),
+        writePolicy: "exclusive",
+        writeSet: ["knowledge/bootstrap/inventory.json", "knowledge/bootstrap/status.yaml"],
+        allowedPaths: ["knowledge/bootstrap/**", "./**"],
         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.",
+        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: [],
-            verdictGate: {
-                fromNodeId: "review-backend-cases-pi",
-                accept: ["VERDICT: pass"],
-                label: "backend case review",
-                lineMode: "first-verdict-line",
-            },
+            commands: [script],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "intermediate",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [script],
+            }),
             cwd: ".",
-            timeoutMs: 60000,
+            timeoutMs: 120000,
         },
     };
 }
-function buildGenerateBackendPytestNode(sources) {
+function buildKgBootstrapProposeNode(sources) {
     return {
-        id: "generate-backend-pytest-pi",
-        depends_on: ["review-backend-cases-gate-shell"],
+        id: "kg-bootstrap-propose-pi",
+        depends_on: ["kg-bootstrap-inventory-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
+        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: [
-            "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",
+            "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 buildExecuteBackendPytestNode(sources) {
+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: "execute-backend-pytest-shell",
-        depends_on: ["generate-backend-pytest-pi"],
+        id: "kg-bootstrap-validate-shell",
+        depends_on: ["kg-bootstrap-propose-pi"],
         role: "verifier",
         executor: "shell",
         complexity: "LOW",
         writePolicy: "read-only",
-        allowedPaths: commonReadOnlyPaths(sources),
+        allowedPaths: ["knowledge/bootstrap/staging/**"],
         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.",
+        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: [
-                "python -m pytest testcase/ --html=reports/backend-test-report.html -v",
-            ],
+            commands: [script],
             verifyEvidence: buildVerifyEvidence({
                 phase: "final",
                 quota: "full",
                 commandSource: "inline",
-                fallbackCommands: [
-                    "python -m pytest testcase/ --html=reports/backend-test-report.html -v",
-                ],
+                fallbackCommands: [script],
                 finalFullRequired: true,
             }),
             cwd: ".",
-            timeoutMs: 300000,
+            timeoutMs: 120000,
         },
     };
 }
-function buildTestRetrospectNode(sources) {
+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",
+        ],
+    },
+];
+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.",
+        ],
+    });
+}
+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: "test-retrospect-pi",
-        depends_on: ["execute-backend-pytest-shell"],
+        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,
+            }),
+            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: "pi",
-        toolProfile: "write",
-        complexity: "MED",
+        executor: "shell",
+        complexity: "LOW",
         writePolicy: "exclusive",
-        writeSet: ["docs/test-reports/**"],
-        allowedPaths: ["docs/test-reports/**"],
+        writeSet: [
+            "knowledge/graph/entities-index.yaml",
+            "knowledge/graph/edges.yaml",
+        ],
+        allowedPaths: ["knowledge/**", "features/**"],
         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"),
+        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,
+        },
     };
 }
-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) {
+function buildKnowledgeGraphBootstrapHybridDag(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.",
+        "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: 3,
-        title: `Backend test DAG: ${taskConfig.title}`,
-        runtimeContract: GENERATED_DAG_RUNTIME_CONTRACT,
+        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: {
-            ...BACKEND_TEST_DEFAULTS,
+            ...KG_BOOTSTRAP_DEFAULTS,
             contextProfile: taskConfig.contextProfile,
         },
-        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        skillsByRole: KG_BOOTSTRAP_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),
+            buildKgBootstrapPreflightNode(sources),
+            buildKgBootstrapInventoryNode(sources),
+            buildKgBootstrapProposeNode(sources),
+            buildKgBootstrapValidateNode(sources),
+            ...multiReview,
+            buildKgBootstrapPromoteNode(sources),
+            buildKgBootstrapMaterializeNode(sources),
         ],
     };
-    applyDefaultReadOnlyRetryPolicy(spec);
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+function buildHybridDagForTemplate(sources, template) {
+    let spec;
+    if (template === "frontend-implementation") {
+        spec = buildFrontendHybridDagFromTask(sources);
+    }
+    else if (template === "frontend-test-dag")
+        spec = buildFrontendTestHybridDag(sources);
+    else if (template === "backend-test-dag")
+        spec = buildBackendTestHybridDag(sources);
+    else if (template === "knowledge-sync-dag")
+        spec = buildKnowledgeSyncHybridDag(sources);
+    else if (template === "knowledge-graph-bootstrap-dag")
+        spec = buildKnowledgeGraphBootstrapHybridDag(sources);
+    else {
+        const standard = buildStandardHybridDagFromTask(sources);
+        if (template === "standard-dag")
+            spec = standard;
+        else if (template === "review-gated-dag")
+            spec = buildReviewGatedHybridDag(standard, sources);
+        else
+            spec = buildSupervisedHybridDag(standard, sources);
+    }
+    spec.sourceBinding = buildDagSourceBinding(sources);
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
 }
 export function buildHybridDagFromTask(sources, options = {}) {
-    if (sources.taskConfig.taskKind === "frontend-implementation" ||
-        options.template === "frontend-implementation") {
-        return buildFrontendHybridDagFromTask(sources);
-    }
-    if (sources.taskConfig.taskKind === "backend-test" ||
-        options.template === "backend-test-dag") {
-        return buildBackendTestHybridDag(sources);
-    }
-    const standard = buildStandardHybridDagFromTask(sources);
-    const template = options.template ?? "standard-dag";
-    if (template === "standard-dag")
-        return standard;
-    if (template === "review-gated-dag")
-        return buildReviewGatedHybridDag(standard, sources);
-    return buildSupervisedHybridDag(standard, sources);
+    const selection = resolveTaskDagTemplateSelection({
+        taskKind: sources.taskConfig.taskKind,
+        title: sources.taskConfig.title,
+        requirementMarkdown: sources.requirementMarkdown,
+        allowedPaths: sources.taskConfig.allowedPaths,
+        requestedTemplate: options.template,
+    });
+    return buildHybridDagForTemplate(sources, selection.template);
 }
 function cloneTask(task, patch = {}) {
     return { ...task, ...patch };
@@ -1806,8 +3838,19 @@ export function defaultHybridDagOutputPath(taskId) {
     return path.join(os.tmpdir(), `${taskId}-hybrid-dag.json`);
 }
 export async function writeHybridDagDraft(sources, outputPath, options = {}) {
-    const template = options.template ?? "standard-dag";
-    const spec = buildHybridDagFromTask(sources, { template });
+    const templateSelection = resolveTaskDagTemplateSelection({
+        taskKind: sources.taskConfig.taskKind,
+        title: sources.taskConfig.title,
+        requirementMarkdown: sources.requirementMarkdown,
+        allowedPaths: sources.taskConfig.allowedPaths,
+        requestedTemplate: options.template,
+    });
+    const template = templateSelection.template;
+    assertTaskAllowedPathsPreflight(sources.taskConfig);
+    const preparedSources = template === "frontend-implementation"
+        ? await prepareFrontendMockSources(sources)
+        : sources;
+    const spec = buildHybridDagForTemplate(preparedSources, template);
     await writeFile(outputPath, `${JSON.stringify(spec, null, 2)}\n`, "utf-8");
     return {
         taskId: sources.taskId,
@@ -1815,6 +3858,7 @@ export async function writeHybridDagDraft(sources, outputPath, options = {}) {
         taskCount: spec.tasks.length,
         nodeIds: spec.tasks.map((task) => task.id),
         template,
+        templateSelection,
     };
 }
 export async function initHybridDagFromTask(repoRoot, taskId, options = {}) {