@tea-agent/loop-agent 0.8.0 → 0.10.0-alpha.0

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

@@ -2,7 +2,7 @@ import { access, readdir, readFile, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { assertValidDagSpec } from "./validate.js";
-import { DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
+import { DEFAULT_DAG_OUTPUT_LANGUAGE, DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { resolveAdapter } from "../../adapters/index.js";
@@ -58,27 +58,38 @@ const HYBRID_SKILLS_BY_ROLE = {
     verifier: ["verification-before-completion", "systematic-debugging"],
     closeout: ["loop-agent", "verification-before-completion"],
 };
+const FRONTEND_DEFAULTS = {
+    ...HYBRID_DEFAULTS,
+    skills: [],
+};
+const FRONTEND_SKILLS_BY_ROLE = {
+    planner: [],
+    scout: [],
+    implementer: [],
+    reviewer: [],
+    supervisor: [],
+    verifier: [],
+    closeout: [],
+};
+const FRONTEND_IMPLEMENTATION_SKILLS = ["frontend-implementation"];
+const FRONTEND_DESIGN_REVIEW_SKILLS = ["frontend-design-review"];
+const FRONTEND_REVIEW_SKILLS = ["frontend-review"];
+const FRONTEND_VERIFICATION_SKILLS = ["frontend-verification"];
 const IMPLEMENT_WRITESET_PLACEHOLDER = "REPLACE/WITH/NARROW/IMPLEMENT/PATHS/**";
 function resolveEnabledExecutors(manifestExecutors) {
     return Object.entries(manifestExecutors)
         .filter(([, config]) => config.enabled !== false)
-        .map(([name]) => name);
+        .map(([name]) => name)
+        .filter((name) => name === "pi");
 }
-function resolveImplementationExecutor(sources) {
-    const enabled = sources.enabledExecutors
-        ? new Set(sources.enabledExecutors)
-        : undefined;
-    if (!enabled || enabled.has("pi"))
-        return "pi";
-    if (enabled.has("cursor"))
-        return "cursor";
-    return "pi";
+function implementationNodeId() {
+    return "implement-pi";
 }
-function implementationNodeId(executor) {
-    return executor === "cursor" ? "implement-cursor" : "implement-pi";
+function repairNodeId() {
+    return "repair-pi";
 }
-function repairNodeId(executor) {
-    return executor === "cursor" ? "repair-cursor" : "repair-pi";
+function frontendImplementationNodeId() {
+    return "frontend-implement-pi";
 }
 function probePathsForWriteSetEntry(entry) {
     const normalized = entry.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -275,6 +286,65 @@ function buildVerifyShellCommands(input) {
     const repoRoot = input.repoRoot;
     return input.commands.map((command) => verifyCommandToShell(repoRoot, command));
 }
+function markdownVerifyCommand(repoRoot, command) {
+    const args = command.split(/\s+/).filter(Boolean);
+    if (args.length === 0 ||
+        args.some((arg) => !/^[a-z0-9@._/:=,+-]+$/i.test(arg))) {
+        return null;
+    }
+    return {
+        args,
+        cwd: repoRoot,
+        label: command,
+    };
+}
+function extractFrontendVerifyCommandsFromMarkdown(input) {
+    if (!input.repoRoot)
+        return { staticCommands: [], behaviorCommands: [] };
+    const markdown = [
+        input.requirementMarkdown,
+        input.constraintMarkdown ?? "",
+    ].join("\n");
+    const commands = new Set();
+    for (const line of markdown.split(/\r?\n/)) {
+        const bulletless = line
+            .trim()
+            .replace(/^[-*]\s*(?:\[[ xX]\]\s*)?/, "")
+            .trim();
+        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)) {
+                commands.add(candidate);
+            }
+        }
+    }
+    const staticCommands = [];
+    const behaviorCommands = [];
+    for (const command of commands) {
+        const verifyCommand = markdownVerifyCommand(input.repoRoot, command);
+        if (!verifyCommand)
+            continue;
+        if (/\b(typecheck|lint|eslint|tsc|build)\b/i.test(command)) {
+            staticCommands.push(verifyCommand);
+            continue;
+        }
+        if (/\b(test|vitest|jest|playwright|cypress|e2e)\b/i.test(command)) {
+            behaviorCommands.push(verifyCommand);
+        }
+    }
+    return { staticCommands, behaviorCommands };
+}
+function chooseFrontendVerifyCommands(input) {
+    if (input.parsedCommands.length > 0) {
+        return { commands: input.parsedCommands, commandSource: "inline" };
+    }
+    if (input.adapterCommands && input.adapterCommands.length > 0) {
+        return { commands: input.adapterCommands, commandSource: "adapter" };
+    }
+    return { commandSource: "inline" };
+}
 function resolveDagVerifyStrategy(taskConfig) {
     return {
         intermediateQuota: taskConfig.dagVerifyStrategy?.intermediateQuota ?? taskConfig.verifyQuota,
@@ -311,6 +381,17 @@ function deriveParallelScoutPaths(taskConfig) {
                 : allowed,
     };
 }
+function deriveFrontendBehaviorPaths(taskConfig) {
+    if (taskConfig.allowedPaths.length === 0)
+        return ["**"];
+    const explicitTestPaths = taskConfig.allowedPaths.filter((entry) => entry.includes("/test/") ||
+        entry.includes("/tests/") ||
+        entry.includes("/e2e/") ||
+        entry.includes("/spec/"));
+    if (explicitTestPaths.length > 0)
+        return explicitTestPaths;
+    return taskConfig.allowedPaths;
+}
 function toTaskRelativeSourcePath(sources, absolutePath) {
     return path
         .relative(sources.taskDir, absolutePath)
@@ -448,6 +529,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         constraintPath,
         requirementMarkdown,
         constraintMarkdown,
+        outputLanguage: manifest.workflowPolicy.dag.outputLanguage,
         referenceDocuments,
         taskConfig,
         enabledExecutors: resolveEnabledExecutors(manifest.executors),
@@ -478,8 +560,7 @@ export function buildStandardHybridDagFromTask(sources) {
     const scoutPaths = deriveParallelScoutPaths(taskConfig);
     const scoutComplexity = mapTaskComplexity(taskConfig.complexity);
     const implementComplexity = resolveWriterComplexity(taskConfig);
-    const writerExecutor = resolveImplementationExecutor(sources);
-    const implementId = implementationNodeId(writerExecutor);
+    const implementId = implementationNodeId();
     const finalVerifyCommands = sources.verifyCommands?.final ?? [];
     const verifyShellCommands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
@@ -524,6 +605,7 @@ export function buildStandardHybridDagFromTask(sources) {
     const spec = {
         version: 2,
         title: `Hybrid DAG: ${taskConfig.title}`,
+        outputLanguage: sources.outputLanguage ?? DEFAULT_DAG_OUTPUT_LANGUAGE,
         objective: extractObjective(sources.requirementMarkdown, taskConfig.title),
         successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
         globalConstraints,
@@ -602,7 +684,7 @@ export function buildStandardHybridDagFromTask(sources) {
                 id: implementId,
                 depends_on: ["plan-pi"],
                 role: "implementer",
-                executor: writerExecutor,
+                executor: "pi",
                 toolProfile: "write",
                 complexity: implementComplexity,
                 writePolicy: "exclusive",
@@ -658,7 +740,501 @@ export function buildStandardHybridDagFromTask(sources) {
     assertValidDagSpec(spec);
     return spec;
 }
+function buildFrontendHybridDagFromTask(sources) {
+    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 spec = {
+        version: 2,
+        title: `Frontend implementation DAG: ${taskConfig.title}`,
+        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"),
+            },
+            {
+                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"],
+                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.",
+                shell: {
+                    commands: [],
+                    verdictGate: {
+                        fromNodeId: "frontend-design-gate-pi",
+                        accept: ["VERDICT: pass"],
+                        label: "frontend design gate",
+                        lineMode: "first-verdict-line",
+                    },
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            },
+            {
+                id: implementId,
+                depends_on: ["frontend-design-gate-shell"],
+                role: "implementer",
+                executor: "pi",
+                toolProfile: "write",
+                complexity: taskConfig.complexity === "large"
+                    ? "HIGH"
+                    : "MED",
+                writePolicy: "exclusive",
+                writeSet: implementPaths.writeSet,
+                allowedPaths: implementPaths.allowedPaths,
+                forbiddenPaths,
+                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.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-static-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 static verification; no worktree writes.",
+                subtask_prompt: "Run deterministic static verification for the frontend implementation.",
+                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,
+                    }),
+                    cwd: ".",
+                    timeoutMs: 300000,
+                },
+            },
+            {
+                id: "frontend-behavior-verify-shell",
+                depends_on: ["frontend-static-verify-shell"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                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.",
+                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,
+                    }),
+                    cwd: ".",
+                    timeoutMs: 300000,
+                },
+            },
+            {
+                id: "frontend-review-pi",
+                depends_on: ["frontend-behavior-verify-shell"],
+                role: "reviewer",
+                executor: "pi",
+                complexity: "HIGH",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                skills: FRONTEND_REVIEW_SKILLS,
+                outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by Findings, Verification Assessment, UX Assessment, and Residual Risks. No file writes.",
+                subtask_prompt: [
+                    "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.",
+                    "Review implementation quality, behavior/state coverage, verification evidence, and maintainability. Read-only: do not modify files.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+            {
+                id: "frontend-review-gate-shell",
+                depends_on: ["frontend-review-pi"],
+                role: "verifier",
+                executor: "shell",
+                complexity: "LOW",
+                writePolicy: "read-only",
+                allowedPaths: readOnlyPaths,
+                forbiddenPaths,
+                outputContract: "Deterministic frontend review verdict gate: exit 0 only when frontend-review-pi emits VERDICT: pass.",
+                subtask_prompt: "Deterministic gate: block downstream closeout unless frontend-review-pi emitted VERDICT: pass.",
+                shell: {
+                    commands: [],
+                    verdictGate: {
+                        fromNodeId: "frontend-review-pi",
+                        accept: ["VERDICT: pass"],
+                        label: "frontend review",
+                        lineMode: "first-verdict-line",
+                    },
+                    cwd: ".",
+                    timeoutMs: 60000,
+                },
+            },
+            {
+                id: "frontend-closeout-pi",
+                depends_on: ["frontend-review-gate-shell"],
+                role: "closeout",
+                executor: "pi",
+                complexity: "MED",
+                writePolicy: "read-only",
+                allowedPaths: taskConfig.allowedPaths.length > 0
+                    ? [...taskConfig.allowedPaths, "docs/**"]
+                    : ["**", "docs/**"],
+                forbiddenPaths,
+                skills: FRONTEND_VERIFICATION_SKILLS,
+                outputContract: "Markdown closeout summary with Changes, Verification Evidence, Review Result, 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.",
+                    "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
+                    sourceContext,
+                ].join("\n\n"),
+            },
+        ],
+    };
+    parseDagSpec(spec);
+    assertValidDagSpec(spec);
+    return spec;
+}
+// ---------------------------------------------------------------------------
+// Backend test DAG template
+// ---------------------------------------------------------------------------
+function buildAnalyzeInputsNode(sources) {
+    return {
+        id: "analyze-inputs-pi",
+        depends_on: [],
+        role: "planner",
+        executor: "pi",
+        complexity: "MED",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Plain Markdown end-to-end test analysis contract (scope, risks, strategy highlights); no file writes.",
+        subtask_prompt: [
+            "Read the task source materials (需求.md, 开发详设.md and other references) and produce a concise end-to-end test analysis contract.",
+            "Cover: backend test scope, risk items, and strategy highlights. Identify key modules, integration points, and boundary conditions.",
+            "Read-only: do not modify code, docs, artifacts, or repository files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildGenerateBackendFunctionalCasesNode(sources) {
+    return {
+        id: "generate-backend-functional-cases-pi",
+        depends_on: ["analyze-inputs-pi"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/md/**"],
+        allowedPaths: ["testcase/md/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        subtask_prompt: [
+            "Based on the upstream test analysis contract, generate structured backend functional test cases in Markdown.",
+            "Each test case ID must use the BE-<MODULE>-<NNN> format (e.g. BE-ORDER-001).",
+            "Write test case files under testcase/md/. Cover positive paths, negative paths, and boundary conditions.",
+            "Stay within writeSet. Do not write root artifacts/**.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildReviewBackendCasesNode(sources) {
+    return {
+        id: "review-backend-cases-pi",
+        depends_on: ["generate-backend-functional-cases-pi"],
+        role: "reviewer",
+        executor: "pi",
+        complexity: "HIGH",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision; followed by Findings and Coverage Assessment. No file writes.",
+        subtask_prompt: [
+            "Review the generated backend functional test cases for completeness and quality.",
+            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+            "Check: coverage of requirement acceptance criteria, case ID format (BE-<MODULE>-<NNN>), positive/negative/boundary coverage, and traceability to source requirements.",
+            "Any Critical/Important finding must force VERDICT: request-revision. Read-only: do not modify files.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildGenerateBackendPytestNode(sources) {
+    return {
+        id: "generate-backend-pytest-pi",
+        depends_on: ["review-backend-cases-pi"],
+        role: "implementer",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "HIGH",
+        writePolicy: "exclusive",
+        writeSet: ["testcase/**"],
+        allowedPaths: ["testcase/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        subtask_prompt: [
+            "Convert the reviewed backend functional test cases into pytest automation code.",
+            "Write test files under testcase/. Each functional test case ID (BE-<MODULE>-<NNN>) must map 1:1 to an automated pytest function for traceability.",
+            "Every generated test file must start with test_ prefix (e.g. test_order.py) to comply with pytest discovery.",
+            "Identify the target project's pytest conventions (conftest.py, fixture patterns, pytest.ini/pyproject.toml config) by reading existing files, but do NOT modify any existing framework files.",
+            "Only create NEW test script files. Do NOT modify conftest.py, pytest.ini, pyproject.toml, setup.cfg, __init__.py, or any other existing file.",
+            "If a file with the target name already exists under testcase/, add a numeric suffix: test_order.py → test_order_01.py → test_order_02.py. Never overwrite or append to existing files. Each test script must be a standalone file.",
+            "Stay within writeSet. Do not write root artifacts/**.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+function buildExecuteBackendPytestNode(sources) {
+    return {
+        id: "execute-backend-pytest-shell",
+        depends_on: ["generate-backend-pytest-pi"],
+        role: "verifier",
+        executor: "shell",
+        complexity: "LOW",
+        writePolicy: "read-only",
+        allowedPaths: commonReadOnlyPaths(sources),
+        forbiddenPaths: commonForbiddenPaths(sources),
+        outputContract: "Archived pytest stdout/stderr with exit codes and HTML report path; no worktree writes.",
+        subtask_prompt: "Run pytest for the backend test suite and capture results.",
+        shell: {
+            commands: [
+                "python -m pytest testcase/ --html=reports/backend-test-report.html -v",
+            ],
+            verifyEvidence: buildVerifyEvidence({
+                phase: "final",
+                quota: "full",
+                commandSource: "inline",
+                fallbackCommands: [
+                    "python -m pytest testcase/ --html=reports/backend-test-report.html -v",
+                ],
+                finalFullRequired: true,
+            }),
+            cwd: ".",
+            timeoutMs: 300000,
+        },
+    };
+}
+function buildTestRetrospectNode(sources) {
+    return {
+        id: "test-retrospect-pi",
+        depends_on: ["execute-backend-pytest-shell"],
+        role: "closeout",
+        executor: "pi",
+        toolProfile: "write",
+        complexity: "MED",
+        writePolicy: "exclusive",
+        writeSet: ["docs/test-reports/**"],
+        allowedPaths: ["docs/test-reports/**"],
+        forbiddenPaths: commonForbiddenPaths(sources),
+        subtask_prompt: [
+            "Read upstream review-backend-cases-pi review report and execute-backend-pytest-shell pytest output, then generate a test retrospective report.",
+            "Write the report under docs/test-reports/ in Markdown. The report must include:",
+            "1) Test coverage summary (total cases, pass rate, failed case analysis)",
+            "2) Review findings and their resolution status",
+            "3) Maturity rating: A (100% coverage + 100% pass + no Critical findings), B (≥80% coverage + ≥90% pass + Low findings only), C (≥60% coverage + ≥70% pass), D (below C thresholds)",
+            "Stay within writeSet. Do not write root artifacts/**.",
+            buildSourceContextBlock(sources),
+        ].join("\n\n"),
+    };
+}
+const BACKEND_TEST_DEFAULTS = {
+    ...HYBRID_DEFAULTS,
+    writePolicy: "read-only",
+};
+const BACKEND_TEST_SKILLS_BY_ROLE = {
+    planner: ["loop-agent"],
+    scout: [],
+    implementer: ["test-driven-development", "verification-before-completion"],
+    reviewer: ["requesting-code-review", "code-review-core"],
+    verifier: ["verification-before-completion", "systematic-debugging"],
+    closeout: ["loop-agent", "verification-before-completion"],
+};
+function buildBackendTestHybridDag(sources) {
+    const { taskConfig } = sources;
+    const sourceContext = buildSourceContextBlock(sources);
+    const readOnlyPaths = commonReadOnlyPaths(sources);
+    const forbiddenPaths = commonForbiddenPaths(sources);
+    const globalConstraints = [
+        ...taskConfig.hardConstraints,
+        ...(sources.constraintMarkdown
+            ? [`See 执行约束.md in task source (${sources.taskId})`]
+            : []),
+        ...STANDARD_GLOBAL_CONSTRAINTS,
+        "backend-test-dag nodes must maintain traceability from requirements to functional cases to pytest automation.",
+        "Functional test case IDs must use BE-<MODULE>-<NNN> format.",
+        "pytest execution must produce HTML reports under reports/.",
+        "pytest automation scripts must use test_ filename prefix for pytest discovery.",
+        "generate-backend-pytest-pi must only create new test files under testcase/; modifying existing framework files (conftest.py, pytest.ini, pyproject.toml) is forbidden.",
+        "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: 2,
+        title: `Backend test 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,
+            contextProfile: taskConfig.contextProfile,
+        },
+        skillsByRole: BACKEND_TEST_SKILLS_BY_ROLE,
+        executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
+        tasks: [
+            buildAnalyzeInputsNode(sources),
+            buildGenerateBackendFunctionalCasesNode(sources),
+            buildReviewBackendCasesNode(sources),
+            buildGenerateBackendPytestNode(sources),
+            buildExecuteBackendPytestNode(sources),
+            buildTestRetrospectNode(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")
@@ -805,7 +1381,7 @@ function buildWriteSetGateNode(sources) {
     };
 }
 function buildSoftVerifyNode(sources) {
-    const implementId = implementationNodeId(resolveImplementationExecutor(sources));
+    const implementId = implementationNodeId();
     const strategy = resolveDagVerifyStrategy(sources.taskConfig);
     const fallbackCommands = ["npm run typecheck"];
     const commands = buildVerifyShellCommands({
@@ -839,8 +1415,8 @@ function buildSoftVerifyNode(sources) {
     };
 }
 function buildProcessSupervisorNode(sources) {
-    const implementId = implementationNodeId(resolveImplementationExecutor(sources));
-    const repairId = repairNodeId(resolveImplementationExecutor(sources));
+    const implementId = implementationNodeId();
+    const repairId = repairNodeId();
     return {
         id: "process-supervisor-pi",
         depends_on: ["soft-verify-shell", implementId],
@@ -891,13 +1467,12 @@ function buildProcessGateNode(sources) {
     };
 }
 function buildRepairNode(sources) {
-    const writerExecutor = resolveImplementationExecutor(sources);
     const implement = resolveImplementPaths(sources.taskConfig);
     return {
-        id: repairNodeId(writerExecutor),
+        id: repairNodeId(),
         depends_on: ["process-gate-shell", "process-supervisor-pi"],
         role: "implementer",
-        executor: writerExecutor,
+        executor: "pi",
         toolProfile: "write",
         complexity: isInteractiveUiTask(sources.taskConfig)
             ? "HIGH"
@@ -919,7 +1494,7 @@ function buildRepairNode(sources) {
     };
 }
 function buildHardVerifyNode(sources) {
-    const repairId = repairNodeId(resolveImplementationExecutor(sources));
+    const repairId = repairNodeId();
     const fallbackCommands = [
         "HARNESS_ALLOW_ACTIVE_DAG_RUNS=1 bash scripts/check-repo.sh",
     ];
@@ -978,7 +1553,7 @@ function buildSupervisedHybridDag(standard, sources) {
     const scoutSrc = getTaskOrThrow(standard, "scout-src");
     const scoutTests = getTaskOrThrow(standard, "scout-tests");
     const plan = getTaskOrThrow(standard, "plan-pi");
-    const implement = getTaskOrThrow(standard, implementationNodeId(resolveImplementationExecutor(sources)));
+    const implement = getTaskOrThrow(standard, implementationNodeId());
     const closeout = getTaskOrThrow(standard, "closeout-pi");
     const authorityDecision = resolveAuthoritySurfaceAudit(sources);
     const reviewDependsOn = authorityDecision.enabled