@tea-agent/loop-agent 0.10.0 → 0.11.0

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

@@ -8,6 +8,7 @@ import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
+import { applySddEmbeddedEnhancements, probeRepoLocalSddSkills, } from "./sdd-embedded.js";
 import { getTaskPaths, loadTaskConfig } from "../../task/runtime.js";
 import { materializeTaskReferenceDocs } from "../../task/source-references.js";
 import { resolveVerifyPreset } from "../../executors/shell-verification.js";
@@ -58,27 +59,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 +287,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 +382,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)
@@ -454,6 +536,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
         enabledExecutors: resolveEnabledExecutors(manifest.executors),
         executorModelMatrix: resolveExecutorModelMatrices(manifest),
         verifyCommands,
+        sddEmbeddedSkills: await probeRepoLocalSddSkills(repoRoot),
     };
 }
 function mergeFinalVerifyCommands(repoRoot, taskConfig, adapterCommands) {
@@ -479,8 +562,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,
@@ -604,7 +686,7 @@ export function buildStandardHybridDagFromTask(sources) {
                 id: implementId,
                 depends_on: ["plan-pi"],
                 role: "implementer",
-                executor: writerExecutor,
+                executor: "pi",
                 toolProfile: "write",
                 complexity: implementComplexity,
                 writePolicy: "exclusive",
@@ -656,11 +738,305 @@ export function buildStandardHybridDagFromTask(sources) {
             },
         ],
     };
+    applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
+    parseDagSpec(spec);
+    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;
 }
 export function buildHybridDagFromTask(sources, options = {}) {
+    if (sources.taskConfig.taskKind === "frontend-implementation" ||
+        options.template === "frontend-implementation") {
+        return buildFrontendHybridDagFromTask(sources);
+    }
     const standard = buildStandardHybridDagFromTask(sources);
     const template = options.template ?? "standard-dag";
     if (template === "standard-dag")
@@ -758,6 +1134,7 @@ function buildReviewGatedHybridDag(standard, sources) {
     const closeout = getTaskOrThrow(spec, "closeout-pi");
     replaceTask(spec, cloneTask(closeout, { depends_on: ["review-gate-shell"] }));
     spec.tasks.splice(spec.tasks.length - 1, 0, buildReviewNode(sources), buildReviewGateNode(sources));
+    applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;
@@ -807,7 +1184,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({
@@ -841,8 +1218,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],
@@ -893,13 +1270,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"
@@ -921,7 +1297,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",
     ];
@@ -980,7 +1356,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
@@ -1028,6 +1404,7 @@ function buildSupervisedHybridDag(standard, sources) {
             cloneTask(closeout, { depends_on: ["decision-pi"] }),
         ],
     };
+    applySddEmbeddedEnhancements(spec, sources.sddEmbeddedSkills ?? new Set());
     parseDagSpec(spec);
     assertValidDagSpec(spec);
     return spec;

package/dist/workflows/dag/node-execution.js

@@ -3,6 +3,7 @@ import { recordDecisionEnvelopeForNode, shouldPauseOnHumanEscalation, writeHuman
 import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { buildDagNodePromptEnvelope } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
+import { assertSkillSnapshotCoversSpec, buildNodePromptFromSnapshot, isDagSkillSnapshotIntegrityError, readSkillSnapshot, } from "./skill-snapshot.js";
 import { resolveDagSkillInstructions, skillInstructionMetadata, } from "./skill-instructions.js";
 import { resolveDagNodeSkills } from "./skills.js";
 import { parseRepairArtifactFromText, validateRepairArtifactScope, } from "./repair-artifact.js";
@@ -17,7 +18,7 @@ export function buildNodePrompt(spec, task, upstream) {
 }
 export async function buildNodePromptWithResolvedSkillInstructions(spec, task, upstream, cwd) {
     const skillNames = resolveDagNodeSkills(spec, task);
-    const resolvedSkillInstructions = task.executor === "cursor" || task.executor === "pi"
+    const resolvedSkillInstructions = task.executor === "pi"
         ? await resolveDagSkillInstructions(skillNames, {
             cwd,
             includeLearnedPatterns: task.role === "implementer",
@@ -55,7 +56,7 @@ function assertRepairArtifactVerdictMatchesSupervisor(input) {
 }
 function findRepairTaskForGate(input) {
     return Array.from(input.tasksById.values()).find((candidate) => candidate.depends_on.includes(input.gateTask.id) &&
-        candidate.id === "repair-cursor");
+        candidate.id === "repair-pi");
 }
 function parseSupervisorRepairArtifact(node) {
     const text = `${node?.assistantText ?? ""}\n${node?.stdout ?? ""}`;
@@ -111,6 +112,45 @@ export async function executeDagNode(input) {
     const { nodeId, tasksById, state, spec, cwd, runDir, executeNode } = input;
     const task = tasksById.get(nodeId);
     const node = state.nodes[nodeId];
+    const failSkillSnapshot = async (error) => {
+        const failedAt = new Date().toISOString();
+        node.startedAt ??= failedAt;
+        node.status = "ERROR";
+        node.stderr = error instanceof Error ? error.message : String(error);
+        node.failureCategory = "skill-snapshot-integrity";
+        node.finishedAt = failedAt;
+        node.lastActivityAt = node.finishedAt;
+        node.durationMs = Math.max(0, Date.now() - new Date(node.startedAt).getTime());
+        state.nodes[nodeId].nodeRecordPath = path.join(runDir, `${nodeId}.json`);
+        await writeNodeRecord(runDir, nodeId, state.nodes[nodeId]);
+        await input.persistState();
+        await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
+    };
+    const isDynamicTask = Boolean(task.dynamicExpansion
+        || task.dynamicReduction
+        || task.dynamicCondition
+        || task.dynamicLoopUntil);
+    let snapshotPrompt;
+    if (state.skillSnapshotRef) {
+        try {
+            const skillSnapshot = await readSkillSnapshot(runDir, state.skillSnapshotRef, {
+                expectedRunId: state.runId,
+            });
+            assertSkillSnapshotCoversSpec(skillSnapshot, spec, state);
+            if (!isDynamicTask) {
+                snapshotPrompt = buildNodePromptFromSnapshot({
+                    spec,
+                    task,
+                    upstream: state.nodes,
+                    snapshot: skillSnapshot,
+                });
+            }
+        }
+        catch (error) {
+            await failSkillSnapshot(error);
+            return;
+        }
+    }
     node.status = "RUNNING";
     node.startedAt = new Date().toISOString();
     node.lastActivityAt = node.startedAt;
@@ -119,10 +159,7 @@ export async function executeDagNode(input) {
     }
     await input.persistState();
     await notifyNodeObserver(input.observer, "onNodeStart", nodeId, state);
-    if (task.dynamicExpansion ||
-        task.dynamicReduction ||
-        task.dynamicCondition ||
-        task.dynamicLoopUntil) {
+    if (isDynamicTask) {
         const started = Date.now();
         try {
             const result = await input.executeDynamicNode({
@@ -165,7 +202,24 @@ export async function executeDagNode(input) {
         await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
         return;
     }
-    const { prompt, resolvedSkills } = await buildNodePromptWithResolvedSkillInstructions(spec, task, state.nodes, cwd);
+    let prompt;
+    let resolvedSkills;
+    try {
+        if (snapshotPrompt) {
+            prompt = snapshotPrompt.prompt;
+            resolvedSkills = snapshotPrompt.resolvedSkills;
+        }
+        else {
+            ({ prompt, resolvedSkills } =
+                await buildNodePromptWithResolvedSkillInstructions(spec, task, state.nodes, cwd));
+        }
+    }
+    catch (error) {
+        if (!isDagSkillSnapshotIntegrityError(error))
+            throw error;
+        await failSkillSnapshot(error);
+        return;
+    }
     node.resolvedSkills = resolvedSkills;
     await writeNodeSkillArtifacts(runDir, nodeId, resolvedSkills);
     const model = resolveModelForTask(task, spec.executorModels);