@tea-agent/loop-agent 0.2.0 → 0.3.0

package/dist/workflows/dag/dynamic-runtime/loop-until.js

@@ -27,7 +27,7 @@ function renderLoopTemplate(template, iteration) {
         .replace(/\{\{\s*iteration\s*\}\}/g, String(iteration))
         .replace(/\{\{\s*iterationStatus\s*\}\}/g, iterationStatus);
 }
-function buildLoopBodyChildTask(input) {
+export function buildLoopBodyChildTask(input) {
     const { parent, bodyTask, iteration, nodeId, bodyIdMap } = input;
     const mappedDepends = bodyTask.dependsOn.map((depId) => bodyIdMap.get(depId) ?? depId);
     return {
@@ -37,6 +37,7 @@ function buildLoopBodyChildTask(input) {
         subtask_prompt: renderLoopTemplate(bodyTask.subtaskPromptTemplate, iteration),
         executor: bodyTask.executor,
         role: bodyTask.role,
+        skills: bodyTask.skills,
         writePolicy: bodyTask.writePolicy,
         allowedPaths: bodyTask.allowedPaths,
         forbiddenPaths: bodyTask.forbiddenPaths,

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -18,6 +18,7 @@ export function buildExpandedChildTask(input) {
         subtask_prompt: subtaskPrompt,
         executor: child.executor,
         role: child.role,
+        skills: child.skills,
         writePolicy: child.writePolicy,
         allowedPaths: renderDynamicPatternList(child.allowedPaths, item, index, expansion.itemName) ?? [],
         forbiddenPaths: renderDynamicPatternList(child.forbiddenPaths, item, index, expansion.itemName) ?? [],

package/dist/workflows/dag/failure-routing.js

@@ -0,0 +1,82 @@
+export const dagProductLineFailureCategoryValues = [
+    "SpecUnclear",
+    "ContractMismatch",
+    "ProductBug",
+    "TestBug",
+    "EnvFailure",
+    "FlakyTest",
+    "RiskyChange",
+    "DependencyFailure",
+    "NeedsHuman",
+    "Unknown",
+];
+const FOLLOW_UP_BY_PRODUCT_LINE = {
+    SpecUnclear: "spec-clarification",
+    ContractMismatch: "architecture-contract-fix",
+    ProductBug: "dev-fix",
+    TestBug: "qa-fix-test",
+    EnvFailure: "env-fix or retry verify",
+    FlakyTest: "flaky-test-analysis",
+    RiskyChange: "human-review or architecture-review",
+    DependencyFailure: "unblock dependency",
+    NeedsHuman: "human-review",
+    Unknown: "human triage",
+};
+function routeToProductLine(input) {
+    const normalized = input.normalizedFailureCategory;
+    if (!normalized || normalized === "success")
+        return undefined;
+    const raw = input.rawFailureCategory?.toLowerCase() ?? "";
+    const nodeId = input.nodeId?.toLowerCase() ?? "";
+    switch (normalized) {
+        case "write-guard":
+            return "RiskyChange";
+        case "auth":
+        case "executor":
+        case "timeout":
+            return "EnvFailure";
+        case "human-required":
+        case "human-rejected":
+        case "decision-envelope":
+            return "NeedsHuman";
+        case "skipped":
+            return "DependencyFailure";
+        case "shell-command":
+            if (raw.includes("flaky"))
+                return "FlakyTest";
+            if (nodeId.includes("test") || raw.includes("test-bug")) {
+                return "TestBug";
+            }
+            return "ProductBug";
+        case "static-error":
+            return "SpecUnclear";
+        case "validation":
+            if (raw.includes("path") ||
+                raw.includes("write") ||
+                raw.includes("forbidden")) {
+                return "RiskyChange";
+            }
+            if (raw.includes("test-bug") || nodeId.includes("test")) {
+                return "TestBug";
+            }
+            if (raw.includes("test-failure") || raw.includes("verify-failure")) {
+                return "ProductBug";
+            }
+            return "SpecUnclear";
+        case "unknown":
+            return "Unknown";
+        default: {
+            const exhaustive = normalized;
+            return exhaustive;
+        }
+    }
+}
+export function routeDagFailure(input) {
+    const productLineFailureCategory = routeToProductLine(input);
+    if (!productLineFailureCategory)
+        return {};
+    return {
+        productLineFailureCategory,
+        recommendedFollowUp: FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory],
+    };
+}

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

@@ -22,9 +22,9 @@ const HYBRID_DEFAULTS = {
 };
 const HYBRID_SKILLS_BY_ROLE = {
     planner: ["loop-agent"],
-    scout: ["ai-engineering-context"],
-    implementer: ["verification-before-completion"],
-    reviewer: ["requesting-code-review"],
+    scout: ["ai-engineering-context", "codebase-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"],
 };

package/dist/workflows/dag/lifecycle.js

@@ -2,6 +2,8 @@ import { access, mkdir, readFile, readdir, rename, } from "node:fs/promises";
 import path from "node:path";
 import { writeJsonAtomic, } from "../../infrastructure/harness/atomic-write.js";
 import { parseDagSpec } from "./types.js";
+import { normalizeDagFailureCategory, } from "./failure-category.js";
+import { routeDagFailure } from "./failure-routing.js";
 const DAG_LIFECYCLE_SCAN_ORDER = [
     "paused",
     "active",
@@ -470,16 +472,106 @@ export async function runDagStatus(repoRoot, rawArgs) {
     console.log(JSON.stringify(report, null, 2));
 }
 export function parseDagDoctorArgs(args) {
-    for (const arg of args) {
+    let runId;
+    let markdown = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--run-id") {
+            runId = args[++i];
+            if (!runId || runId.startsWith("-")) {
+                throw new Error("dag doctor --run-id requires a value");
+            }
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            if (!runId)
+                throw new Error("dag doctor --run-id requires a value");
+            continue;
+        }
+        if (arg === "--markdown") {
+            markdown = true;
+            continue;
+        }
         if (arg.startsWith("-")) {
             throw new Error(`unknown dag doctor flag: ${arg}`);
         }
         throw new Error(`unexpected positional argument: ${arg}`);
     }
-    return {};
+    return { runId, markdown };
+}
+function findDoctorFailureNode(state) {
+    if (state.pausedByNodeId) {
+        const node = state.nodes[state.pausedByNodeId];
+        return {
+            nodeId: state.pausedByNodeId,
+            status: node?.status,
+            rawFailureCategory: node?.failureCategory,
+        };
+    }
+    const errorEntry = Object.entries(state.nodes).find(([, node]) => node.status === "ERROR");
+    const skippedEntry = Object.entries(state.nodes).find(([, node]) => node.status === "SKIPPED");
+    const selected = errorEntry ?? skippedEntry;
+    if (!selected) {
+        return {
+            rawFailureCategory: state.failureCategory,
+            status: state.status,
+        };
+    }
+    return {
+        nodeId: selected[0],
+        status: selected[1].status,
+        rawFailureCategory: selected[1].failureCategory,
+    };
+}
+async function formatDagDoctorMarkdown(repoRoot, runId) {
+    const located = await locateDagRun(repoRoot, runId);
+    if (!located) {
+        throw new Error(`dag run not found: ${runId}`);
+    }
+    const state = await readDagRunState(located.runDir);
+    const summary = await buildDagStatusReport(repoRoot, runId);
+    const failure = findDoctorFailureNode(state);
+    const rawFailureCategory = failure.rawFailureCategory ??
+        (state.status === "paused" ? "human-required" : state.failureCategory);
+    const failureStatus = state.status === "paused" ? "paused" : failure.status;
+    const normalizedCategory = normalizeDagFailureCategory(rawFailureCategory, failureStatus ?? state.status);
+    const routing = routeDagFailure({
+        rawFailureCategory,
+        normalizedFailureCategory: normalizedCategory,
+        nodeId: failure.nodeId,
+    });
+    const evidence = failure.nodeId
+        ? path.join(located.runDir, failure.nodeId, "result.summary.md")
+        : path.join(located.runDir, "state.json");
+    const nextCommand = summary.nextRecommendedAction ||
+        routing.recommendedFollowUp ||
+        "Inspect run facts and choose a recovery path.";
+    return [
+        "## Diagnosis",
+        "",
+        `- run id: ${runId}`,
+        `- lifecycle: ${located.lifecycle}`,
+        `- failed node: ${failure.nodeId ?? "-"}`,
+        `- raw failure: ${rawFailureCategory ?? "-"}`,
+        `- normalized category: ${normalizedCategory}`,
+        `- product-line category: ${routing.productLineFailureCategory ?? "-"}`,
+        `- recommended follow-up: ${routing.recommendedFollowUp ?? "-"}`,
+        `- evidence: ${evidence}`,
+        `- next command: ${nextCommand}`,
+        "",
+    ].join("\n");
 }
 export async function runDagDoctor(repoRoot, rawArgs) {
-    parseDagDoctorArgs(rawArgs);
+    const parsed = parseDagDoctorArgs(rawArgs);
+    if (parsed.runId) {
+        if (parsed.markdown) {
+            console.log(await formatDagDoctorMarkdown(repoRoot, parsed.runId));
+            return;
+        }
+        console.log(JSON.stringify(await buildDagStatusReport(repoRoot, parsed.runId), null, 2));
+        return;
+    }
     const report = await buildDagDoctorReport(repoRoot);
     console.log(JSON.stringify(report, null, 2));
 }

package/dist/workflows/dag/report.js

@@ -7,6 +7,7 @@ import { repairArtifactSchema } from "./repair-artifact.js";
 import { dagRunDirExists, getDagRunDir, locateDagRun, readDagRunSpec, readDagRunState, } from "./lifecycle.js";
 export const DAG_CLOSEOUT_DRAFT_DISCLAIMER = "> **Advisory only.** Derived from completed run facts. Canonical source remains `dag report --json` and `.harness/dag-runs/completed/<run-id>/`. Do not treat this draft as authoritative.";
 import { dagNormalizedFailureCategorySchema, normalizeDagFailureCategory, } from "./failure-category.js";
+import { dagProductLineFailureCategoryValues, routeDagFailure, } from "./failure-routing.js";
 import { DAG_RECOVERY_ACTIONS, planDagRecovery, } from "./recovery-recommendation.js";
 import { dagNodeExecutorSchema, dagNodeStatusSchema, LEGACY_TOP_LEVEL_MODELS_ERROR, parseDagSpec, resolveModelForTask, } from "./types.js";
 export const DAG_REPORT_SCHEMA_VERSION = 1;
@@ -21,6 +22,7 @@ const dagRunStatusSchema = z.enum([
     "paused",
 ]);
 const dagRecoveryActionSchema = z.enum(DAG_RECOVERY_ACTIONS);
+const dagProductLineFailureCategorySchema = z.enum(dagProductLineFailureCategoryValues);
 const dagArtifactRefSchema = z
     .object({
     path: z.string(),
@@ -44,6 +46,8 @@ const dagReportPrimaryFailureSchema = z
     nodeStatus: dagNodeStatusSchema.optional(),
     failureCategory: z.string().optional(),
     normalizedFailureCategory: dagNormalizedFailureCategorySchema.optional(),
+    productLineFailureCategory: dagProductLineFailureCategorySchema.optional(),
+    recommendedFollowUp: z.string().optional(),
 })
     .strict();
 const dagReportDownstreamSkippedNodeSchema = z
@@ -51,6 +55,8 @@ const dagReportDownstreamSkippedNodeSchema = z
     nodeId: z.string(),
     failureCategory: z.string().optional(),
     normalizedFailureCategory: dagNormalizedFailureCategorySchema.optional(),
+    productLineFailureCategory: dagProductLineFailureCategorySchema.optional(),
+    recommendedFollowUp: z.string().optional(),
 })
     .strict();
 const dagConvergencePassArtifactRefSchema = z
@@ -130,6 +136,8 @@ const dagNodeReportRowSchema = z
     tokensUsed: z.number().nonnegative().optional(),
     failureCategory: z.string().optional(),
     normalizedFailureCategory: dagNormalizedFailureCategorySchema.optional(),
+    productLineFailureCategory: dagProductLineFailureCategorySchema.optional(),
+    recommendedFollowUp: z.string().optional(),
     recoveryRecommendation: dagRecoveryRecommendationSchema.optional(),
     backend: z.enum(["sdk", "cli"]).optional(),
     sdkAttempted: z.boolean().optional(),
@@ -150,6 +158,8 @@ const dagRunReportEntrySchema = z
     finishedAt: z.string().optional(),
     failureCategory: z.string().optional(),
     normalizedFailureCategory: dagNormalizedFailureCategorySchema.optional(),
+    productLineFailureCategory: dagProductLineFailureCategorySchema.optional(),
+    recommendedFollowUp: z.string().optional(),
     recoveryRecommendation: dagRecoveryRecommendationSchema.optional(),
     primaryFailure: dagReportPrimaryFailureSchema,
     primaryRecovery: dagRecoveryRecommendationSchema,
@@ -250,12 +260,18 @@ function buildPrimaryFailure(run, primaryNode) {
             nodeStatus: primaryNode.status,
             failureCategory: primaryNode.failureCategory,
             normalizedFailureCategory: primaryNode.normalizedFailureCategory,
+            productLineFailureCategory: primaryNode.productLineFailureCategory,
+            recommendedFollowUp: primaryNode.recommendedFollowUp,
         };
     }
     return {
         scope: "run",
         failureCategory: run.failureCategory,
         normalizedFailureCategory: run.normalizedFailureCategory,
+        ...routeDagFailure({
+            rawFailureCategory: run.failureCategory,
+            normalizedFailureCategory: run.normalizedFailureCategory,
+        }),
     };
 }
 function resolvePrimaryRecovery(run, primaryNode) {
@@ -302,6 +318,8 @@ function collectDownstreamSkippedNodes(nodes, spec, primaryNode) {
         nodeId: node.nodeId,
         failureCategory: node.failureCategory,
         normalizedFailureCategory: node.normalizedFailureCategory,
+        productLineFailureCategory: node.productLineFailureCategory,
+        recommendedFollowUp: node.recommendedFollowUp,
     }));
 }
 function isFailedReportRun(run) {
@@ -342,6 +360,12 @@ export async function buildDagRunReportEntry(input) {
                 continue;
             const task = tasks.get(nodeId);
             const normalizedFailureCategory = normalizeDagFailureCategory(node.failureCategory, node.status);
+            const failureRouting = routeDagFailure({
+                rawFailureCategory: node.failureCategory,
+                normalizedFailureCategory,
+                nodeId,
+                executor: node.executor,
+            });
             nodes.push({
                 nodeId,
                 rank,
@@ -355,6 +379,7 @@ export async function buildDagRunReportEntry(input) {
                 tokensUsed: node.tokensUsed,
                 failureCategory: node.failureCategory,
                 normalizedFailureCategory,
+                ...failureRouting,
                 recoveryRecommendation: planDagRecovery({
                     status: node.status,
                     normalizedFailureCategory,
@@ -406,6 +431,11 @@ export async function buildDagRunReportEntry(input) {
         lifecycle: input.lifecycle,
         runStatus: input.state.status,
     });
+    const runFailureRouting = routeDagFailure({
+        rawFailureCategory: runRecoverySource.failureCategory,
+        normalizedFailureCategory: runRecoverySource.normalizedFailureCategory,
+        nodeId: "nodeId" in runRecoverySource ? runRecoverySource.nodeId : undefined,
+    });
     const partialEntry = {
         runId: input.state.runId,
         title: input.state.title,
@@ -416,6 +446,7 @@ export async function buildDagRunReportEntry(input) {
         finishedAt: input.state.finishedAt,
         failureCategory: input.state.failureCategory,
         normalizedFailureCategory,
+        ...runFailureRouting,
         recoveryRecommendation,
         pausedByNodeId: input.state.pausedByNodeId,
         pauseReason: input.state.pauseReason,
@@ -638,11 +669,15 @@ function formatPrimaryFailureSection(run) {
         return [
             `- **Node**: ${failure.nodeId} (${failure.nodeStatus ?? "unknown"})`,
             `- **Category (raw/normalized)**: ${failure.failureCategory ?? "-"} / ${failure.normalizedFailureCategory ?? "-"}`,
+            `- **Product-line category**: ${failure.productLineFailureCategory ?? "-"}`,
+            `- **Recommended follow-up**: ${failure.recommendedFollowUp ?? "-"}`,
         ];
     }
     return [
         `- **Scope**: run`,
         `- **Category (raw/normalized)**: ${failure.failureCategory ?? "-"} / ${failure.normalizedFailureCategory ?? "-"}`,
+        `- **Product-line category**: ${failure.productLineFailureCategory ?? "-"}`,
+        `- **Recommended follow-up**: ${failure.recommendedFollowUp ?? "-"}`,
     ];
 }
 function formatPrimaryRecoverySection(run) {
@@ -784,7 +819,7 @@ export function formatDagReportHandoffMarkdown(report) {
                 ? `- **Failure (raw/normalized)**: ${node.failureCategory} / ${node.normalizedFailureCategory ?? "-"}`
                 : "", `- **Executor**: ${node.executor}${node.backend ? ` (backend: ${node.backend})` : ""}`, `- **Model**: ${node.model ?? "—"}`, `- **Duration**: ${formatDuration(node.durationMs)}`, `- **Tokens**: ${formatTokens(node.tokensUsed)}`, `- **Started**: ${formatTimestamp(node.startedAt)}`, `- **Finished**: ${formatTimestamp(node.finishedAt)}`, "");
         }
-        lines.push("## Failures", ...formatFailureSection(run), "", "## Recovery Plan", ...formatRecoveryPlanSection(run), "", "## Artifacts", ...formatArtifactsSection(run), "", "## Suggested Next Action", `- ${suggestedNextAction(run)}`, "");
+        lines.push("## Failures", ...formatFailureSection(run), "", "## Recovery Plan", ...formatRecoveryPlanSection(run), "", "## Operator Next Steps", ...formatRecommendedOperatorAction(run), "", "## Artifacts", ...formatArtifactsSection(run), "", "## Suggested Next Action", `- ${suggestedNextAction(run)}`, "");
         return lines
             .filter((line) => line !== undefined)
             .join("\n");
@@ -869,6 +904,8 @@ function formatCloseoutPrimaryFailureSection(run) {
             `- **Scope**: node`,
             `- **Node**: ${failure.nodeId} (${failure.nodeStatus ?? "unknown"})`,
             `- **Category (raw/normalized)**: ${failure.failureCategory ?? "-"} / ${failure.normalizedFailureCategory ?? "-"}`,
+            `- **Product-line category**: ${failure.productLineFailureCategory ?? "-"}`,
+            `- **Recommended follow-up**: ${failure.recommendedFollowUp ?? "-"}`,
         ];
     }
     if (run.primaryRecovery.action === "none" &&
@@ -879,6 +916,8 @@ function formatCloseoutPrimaryFailureSection(run) {
     return [
         `- **Scope**: ${failure.scope}`,
         `- **Category (raw/normalized)**: ${failure.failureCategory ?? "-"} / ${failure.normalizedFailureCategory ?? "-"}`,
+        `- **Product-line category**: ${failure.productLineFailureCategory ?? "-"}`,
+        `- **Recommended follow-up**: ${failure.recommendedFollowUp ?? "-"}`,
     ];
 }
 function formatCloseoutRecoverySection(run) {
@@ -939,6 +978,39 @@ function formatRemainingRisksSection(run) {
     return risks;
 }
 export function formatDagCloseoutDraftMarkdown(run) {
+    if (isFailedReportRun(run)) {
+        const lines = [
+            `# Failure Handoff: ${run.runId}`,
+            "",
+            DAG_CLOSEOUT_DRAFT_DISCLAIMER,
+            "",
+            "## What failed",
+            ...formatCloseoutPrimaryFailureSection(run),
+            "",
+            "## Evidence",
+            ...formatCloseoutVerificationEvidence(run),
+            "",
+            "## Classification",
+            `- raw_failure_category: ${run.primaryFailure.failureCategory ?? "-"}`,
+            `- dag_normalized_failure_category: ${run.primaryFailure.normalizedFailureCategory ?? "-"}`,
+            `- product_line_failure_category: ${run.primaryFailure.productLineFailureCategory ?? "-"}`,
+            `- recommended_follow_up: ${run.primaryFailure.recommendedFollowUp ?? "-"}`,
+            "",
+            "## Recommended follow-up",
+            ...formatCloseoutRecoverySection(run),
+            "",
+            "## Safe retry conditions",
+            `- Retry only after completing \`${run.primaryFailure.recommendedFollowUp ?? run.primaryRecovery.action}\` and preserving the original DAG run facts.`,
+            "- Do not rewrite `.harness/dag-runs/completed/**`; create a new run or task artifact for follow-up evidence.",
+            "",
+            "## Human decision needed",
+            run.primaryRecovery.humanRequired
+                ? "- Yes. Human review is required before retry or promotion."
+                : "- No required human gate was derived, but review the failure evidence before retry.",
+            "",
+        ];
+        return lines.join("\n");
+    }
     const lines = [
         `# DAG Closeout Draft: ${run.runId}`,
         "",

package/dist/workflows/dag/skills.js

@@ -4,10 +4,10 @@
  */
 export const DEFAULT_SKILLS_BY_ROLE = {
     planner: ["loop-agent"],
-    scout: ["ai-engineering-context"],
-    implementer: ["verification-before-completion"],
+    scout: ["ai-engineering-context", "codebase-scout"],
+    implementer: ["test-driven-development", "verification-before-completion"],
     verifier: ["verification-before-completion", "systematic-debugging"],
-    reviewer: ["requesting-code-review"],
+    reviewer: ["requesting-code-review", "code-review-core"],
     supervisor: ["verification-before-completion", "loop-agent"],
     closeout: ["loop-agent", "verification-before-completion"],
 };

package/dist/workflows/dag/types.js

@@ -94,6 +94,7 @@ export const dagStaticConfigSchema = z.object({
 export const dagDynamicExpansionChildTaskSchema = z.object({
     executor: dagNodeExecutorSchema.default("pi"),
     role: dagRoleSchema.optional(),
+    skills: z.array(z.string()).optional(),
     complexity: dagComplexitySchema.default("LOW"),
     subtaskPromptTemplate: z.string().min(1),
     outputContract: z.string().optional(),
@@ -153,6 +154,7 @@ export const dagDynamicLoopBodyTaskSchema = z.object({
     dependsOn: z.array(z.string()).default([]),
     executor: dagNodeExecutorSchema.default("pi"),
     role: dagRoleSchema.optional(),
+    skills: z.array(z.string()).optional(),
     complexity: dagComplexitySchema.default("LOW"),
     subtaskPromptTemplate: z.string().min(1),
     outputContract: z.string().optional(),

package/dist/workflows/dynamic/compile.js

@@ -40,6 +40,9 @@ function dagRoleForNode(node) {
 function executorForAgentLikeNode(node) {
     return node.executor ?? "pi";
 }
+function nodeSkillsField(node) {
+    return node.skills && node.skills.length > 0 ? { skills: node.skills } : {};
+}
 function dagWriteFields(spec, node) {
     if (node?.writePolicy === "none") {
         return {
@@ -111,6 +114,7 @@ function compileHumanGateNode(spec, node) {
         executor: "pi",
         role: "supervisor",
         ...dagWriteFields(spec, node),
+        ...nodeSkillsField(node),
         decisionGate: { enabled: true, mode: "pause-on-human" },
         outputContract: node.approvalSchema
             ? `Workflow approvalSchema:\n${JSON.stringify(node.approvalSchema, null, 2)}`
@@ -172,6 +176,7 @@ function compileLoopBodyTask(spec, node) {
         dependsOn: node.dependsOn,
         executor,
         role: dagRoleForNode(node),
+        ...nodeSkillsField(node),
         complexity: node.type === "reduce_agent" ? "MED" : "LOW",
         subtaskPromptTemplate: buildAgentPrompt(node),
         staticResultTemplate: node.staticResultTemplate ?? node.transform?.template ?? undefined,
@@ -189,6 +194,7 @@ function compileLoopUntilNode(spec, node) {
         executor: "static",
         role: dagRoleForNode(node),
         ...dagWriteFields(spec, node),
+        ...nodeSkillsField(node),
         static: {
             resultMarkdown: `Dynamic loop_until barrier for ${node.id}.`,
         },
@@ -212,6 +218,7 @@ function compileAgentLikeNode(spec, node) {
             executor: "static",
             role: dagRoleForNode(node),
             ...dagWriteFields(spec, node),
+            ...nodeSkillsField(node),
             static: {
                 resultMarkdown: node.staticResultTemplate ?? `Workflow node ${node.id} completed.`,
             },
@@ -226,6 +233,7 @@ function compileAgentLikeNode(spec, node) {
         executor: "pi",
         role: dagRoleForNode(node),
         ...dagWriteFields(spec, node),
+        ...nodeSkillsField(node),
         outputContract: stringifyOutputSchema(node.outputSchema),
     };
 }
@@ -258,6 +266,7 @@ function compileDynamicExpansionNode(spec, node) {
     const childTask = {
         executor: childExecutor,
         role: dagRoleForNode(node),
+        ...nodeSkillsField(node),
         complexity: "LOW",
         subtaskPromptTemplate: childPrompt,
         staticResultTemplate: node.staticResultTemplate,
@@ -273,6 +282,7 @@ function compileDynamicExpansionNode(spec, node) {
         writePolicy: "none",
         allowedPaths: [],
         forbiddenPaths: [],
+        ...nodeSkillsField(node),
         static: {
             resultMarkdown: `Dynamic ${node.type} expansion barrier for ${node.id}.`,
         },
@@ -299,6 +309,7 @@ function compileDynamicReductionNode(spec, node) {
         executor: "static",
         role: dagRoleForNode(node),
         ...dagWriteFields(spec, node),
+        ...nodeSkillsField(node),
         static: {
             resultMarkdown: `Dynamic reducer ${node.reducer?.type ?? "unknown"} for ${node.id}.`,
         },

package/dist/workflows/dynamic/spec.js

@@ -46,6 +46,7 @@ export const workflowNodeSchema = z.object({
     dependsOn: z.array(z.string()).default([]),
     executor: z.enum(["pi", "static"]).optional(),
     role: z.string().optional(),
+    skills: z.array(z.string().min(1)).optional(),
     prompt: z.string().optional(),
     staticResultTemplate: z.string().optional(),
     writePolicy: z.enum(["none", "read-only", "exclusive"]).optional(),