intentdna 1.2.2 → 1.3.0

package/dist/runtime/settings-adapter.js

@@ -1,23 +1,14 @@
 /**
  * Intent DNA — Settings Adapter
  *
- * Compiles DNA hook scripts into Claude Code settings.json
- * hook configurations for all supported hook events.
+ * Compiles DNA hook events into Claude Code settings.json
+ * hook configurations for the dna-hook binary.
  *
  * See docs/references/cc-source-analysis.md §2 for the full hook event catalog.
  */
 import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-// Hook event → script filename mapping
-const HOOK_FILE_MAP = [
-    ["preToolUse", "dna-pre-tool-use.sh"],
-    ["postToolUse", "dna-post-tool-use.sh"],
-    ["userPromptSubmit", "dna-user-prompt-submit.sh"],
-    ["subagentStop", "dna-subagent-stop.sh"],
-    ["preCompact", "dna-pre-compact.sh"],
-    ["notification", "dna-notification.sh"],
-];
-// HookScripts key → Claude Code settings event name
+// ── Plugin Mode (Node.js hooks via dna-hook binary) ───────
+/** Hook event key → Claude Code settings event name */
 const HOOK_EVENT_MAP = {
     preToolUse: "PreToolUse",
     postToolUse: "PostToolUse",
@@ -26,44 +17,59 @@ const HOOK_EVENT_MAP = {
     preCompact: "PreCompact",
     notification: "Notification",
 };
-// ── Compile ────────────────────────────────────────────────
 /**
- * Compile DNA hook scripts into settings.json hook configuration.
- * Registers all non-null hook scripts from HookScripts.
+ * Compile settings.json hook configuration for dna-hook binary.
+ * Uses `dna-hook <event>` commands.
  */
-export function compileSettingsFromHooks(hooksDir, scripts) {
+export function compilePluginSettings(enabledEvents, timeout = 10) {
     const settings = { hooks: {} };
-    for (const [key, filename] of HOOK_FILE_MAP) {
-        if (scripts[key]) {
-            const eventName = HOOK_EVENT_MAP[key];
-            settings.hooks[eventName] = [
-                {
-                    matcher: "",
-                    hooks: [
-                        {
-                            type: "command",
-                            command: `bash ${join(hooksDir, filename)}`,
-                        },
-                    ],
-                },
-            ];
-        }
+    for (const key of enabledEvents) {
+        const eventName = HOOK_EVENT_MAP[key];
+        if (!eventName)
+            continue;
+        settings.hooks[eventName] = [
+            {
+                matcher: "",
+                hooks: [
+                    {
+                        type: "command",
+                        command: `dna-hook ${eventName}`,
+                        ...(timeout > 0 ? { timeout } : {}),
+                    },
+                ],
+            },
+        ];
     }
     return settings;
 }
 /**
- * @deprecated Use compileSettingsFromHooks instead
+ * Determine which hook events are needed based on IR content.
  */
-export function compileSettings(hooksDir, hasPreHook, hasPostHook) {
-    const scripts = {
-        preToolUse: hasPreHook ? "exists" : null,
-        postToolUse: hasPostHook ? "exists" : null,
-        userPromptSubmit: null,
-        subagentStop: null,
-        preCompact: null,
-        notification: null,
-    };
-    return compileSettingsFromHooks(hooksDir, scripts);
+export function detectEnabledEvents(ir) {
+    const events = [];
+    const hasGates = ir.pre_execution_gates.length > 0;
+    const hasFilters = ir.tool_filters.length > 0;
+    const hasRoleScope = ir.roles_scope_map && ir.roles_scope_map.length > 0;
+    const hasCheckpoints = ir.step_checkpoints && ir.step_checkpoints.length > 0;
+    if (hasGates || hasFilters || hasRoleScope || hasCheckpoints) {
+        events.push("preToolUse");
+    }
+    if (ir.post_execution_validators.length > 0) {
+        events.push("postToolUse");
+    }
+    if (ir.prompt_directives.some(d => d.priority === "high")) {
+        events.push("userPromptSubmit");
+    }
+    if (hasRoleScope) {
+        events.push("subagentStop");
+    }
+    if (ir.prompt_directives.length > 0) {
+        events.push("preCompact");
+    }
+    if (hasGates || hasFilters) {
+        events.push("notification");
+    }
+    return events;
 }
 // ── File Operations ────────────────────────────────────────
 /**
@@ -85,14 +91,20 @@ export async function mergeSettingsFile(dnaSettings, settingsPath) {
     for (const [eventName, entries] of Object.entries(dnaSettings.hooks)) {
         const existingEntries = (mergedHooks[eventName] ?? []);
         // Remove existing DNA hooks, keep user hooks
-        const nonDNA = existingEntries.filter((h) => !JSON.stringify(h).includes("dna-"));
+        const nonDNA = existingEntries.filter((h) => {
+            const s = JSON.stringify(h);
+            return !s.includes("dna-") && !s.includes("dna-hook");
+        });
         mergedHooks[eventName] = [...nonDNA, ...entries];
     }
     // Remove DNA hook events that are no longer generated
     for (const eventName of Object.values(HOOK_EVENT_MAP)) {
         if (!dnaSettings.hooks[eventName] && mergedHooks[eventName]) {
             const entries = mergedHooks[eventName];
-            const nonDNA = entries.filter((h) => !JSON.stringify(h).includes("dna-"));
+            const nonDNA = entries.filter((h) => {
+                const s = JSON.stringify(h);
+                return !s.includes("dna-") && !s.includes("dna-hook");
+            });
             if (nonDNA.length > 0) {
                 mergedHooks[eventName] = nonDNA;
             }
@@ -104,4 +116,3 @@ export async function mergeSettingsFile(dnaSettings, settingsPath) {
     existing.hooks = mergedHooks;
     await writeFile(settingsPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
 }
-//# sourceMappingURL=settings-adapter.js.map

package/dist/runtime/skill-adapter.d.ts

@@ -20,4 +20,3 @@ export interface SkillResult {
 export declare function compileWorkflowToSkill(plan: WorkflowPlan, roles: Record<string, RoleDef>, ir?: ConstraintIR, variables?: Record<string, string>): SkillResult;
 export declare function writeSkillFiles(results: SkillResult[], outputDir: string): Promise<string[]>;
 export declare function removeSkillFiles(outputDir: string): Promise<number>;
-//# sourceMappingURL=skill-adapter.d.ts.map

package/dist/runtime/skill-adapter.js

@@ -17,11 +17,15 @@ const SENTINEL = "<!-- intentdna:managed — do not edit manually -->";
  */
 export function compileWorkflowToSkill(plan, roles, ir, variables) {
     const lines = [];
+    const skillName = `dna-${toKebabCase(plan.name)}`;
     // Frontmatter
     lines.push("---");
-    lines.push(`name: ${toKebabCase(plan.name)}`);
-    lines.push(`description: "Use when user says /${toKebabCase(plan.name)}. ${escapeYaml(plan.description || plan.name)}"`);
+    lines.push(`name: ${skillName}`);
+    lines.push(`description: "Use when user says /${skillName}. ${escapeYaml(plan.description || plan.name)}"`);
     lines.push("user-invocable: true");
+    lines.push("triggers:");
+    lines.push(`  - "${plan.name}"`);
+    lines.push(`  - "run ${plan.name}"`);
     lines.push("---");
     lines.push("");
     // Sentinel
@@ -29,104 +33,106 @@ export function compileWorkflowToSkill(plan, roles, ir, variables) {
     lines.push(`<!-- Compiled: ${new Date().toISOString()} -->`);
     lines.push("");
     // Title
-    lines.push(`# /${plan.name} [task-id]`);
+    lines.push(`# /${skillName} [task-id]`);
     lines.push("");
-    lines.push(plan.description);
-    lines.push("");
-    // Roles table
-    lines.push("## Roles");
-    lines.push("");
-    lines.push("| Role | Agent | Tools | Deny | Scope (write) |");
-    lines.push("|------|-------|-------|------|---------------|");
-    const usedRoles = new Set(plan.steps.map((s) => s.role));
-    for (const roleName of usedRoles) {
-        const role = roles[roleName];
-        if (!role)
-            continue;
-        const agent = `dna-${toKebabCase(roleName)}`;
-        const tools = role.tool_permissions?.allow?.join(", ") || "all";
-        const deny = role.tool_permissions?.deny?.join(", ") || "—";
-        const scope = role.scope?.write?.join(", ") || "—";
-        lines.push(`| ${roleName} | ${agent} | ${tools} | ${deny} | ${scope} |`);
+    // Purpose
+    if (plan.description) {
+        lines.push("<Purpose>");
+        lines.push(plan.description);
+        lines.push("</Purpose>");
+        lines.push("");
     }
-    lines.push("");
-    // Process
-    lines.push("## Process");
-    lines.push("");
+    // Steps
+    const usedRoles = new Set(plan.steps.map((s) => s.role));
+    lines.push("<Steps>");
+    let stepNumber = 0;
     for (let i = 0; i < plan.parallel_groups.length; i++) {
         const group = plan.parallel_groups[i];
-        const isParallel = group.step_ids.length > 1;
-        if (isParallel) {
-            lines.push(`### Group ${i + 1} (parallel)`);
-        }
         for (const stepId of group.step_ids) {
+            stepNumber++;
             const step = plan.steps.find((s) => s.id === stepId);
             const agent = `@dna-${toKebabCase(step.role)}`;
             const runIf = step.run_if ? ` (${step.run_if})` : "";
             const optional = step.optional ? " (optional)" : "";
-            const modeTag = step.mode ? ` [mode: ${step.mode}]` : "";
-            lines.push(`${i + 1}. **${step.id}** → ${agent}${runIf}${optional}${modeTag}`);
-            if (step.mode) {
-                lines.push(`   Before starting: \`echo '{"active_mode":"${step.mode}","set_at":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","set_by":"skill:${toKebabCase(plan.name)}:${step.id}"}' > .dna/mode\``);
-            }
+            lines.push(`${stepNumber}. **${step.id}** → ${agent}${runIf}${optional}`);
             lines.push(`   ${step.description}`);
+            if (step.prompt) {
+                lines.push(`   Prompt: ${step.prompt}`);
+            }
         }
     }
+    lines.push("</Steps>");
     lines.push("");
-    // Retry
-    if (plan.retry.max_retries > 0) {
-        lines.push("## Retry Policy");
-        lines.push("");
-        lines.push(`- Max retries: ${plan.retry.max_retries}`);
-        if (plan.retry.retry_from) {
-            lines.push(`- Retry from: ${plan.retry.retry_from}`);
-        }
-        for (const t of plan.transitions) {
-            if (t.condition === "fail") {
-                lines.push(`- On **${t.from}** fail → go to **${t.to}**`);
-            }
-        }
+    // Tool_Usage — only if roles have permissions or scope
+    const toolUsageLines = [];
+    for (const roleName of usedRoles) {
+        const role = roles[roleName];
+        if (!role)
+            continue;
+        const allowed = role.tool_permissions?.allow?.join(", ") || "all";
+        const denied = role.tool_permissions?.deny?.join(", ") || "none";
+        const writeScope = role.scope?.write?.join(", ") || "none";
+        toolUsageLines.push(`### ${roleName}`);
+        toolUsageLines.push(`- Allowed: ${allowed}`);
+        toolUsageLines.push(`- Denied: ${denied}`);
+        toolUsageLines.push(`- Write scope: ${writeScope}`);
+    }
+    if (toolUsageLines.length > 0) {
+        lines.push("<Tool_Usage>");
+        lines.push(...toolUsageLines);
+        lines.push("</Tool_Usage>");
         lines.push("");
     }
-    // Guidelines from IR
+    // Constraints — IR prompt_directives grouped by priority
     if (ir && ir.prompt_directives.length > 0) {
-        lines.push("## Guidelines");
-        lines.push("");
+        lines.push("<Constraints>");
         const high = ir.prompt_directives.filter((d) => d.priority === "high");
         const medium = ir.prompt_directives.filter((d) => d.priority === "medium");
+        const low = ir.prompt_directives.filter((d) => d.priority !== "high" && d.priority !== "medium");
         if (high.length > 0) {
-            lines.push("### Critical");
+            lines.push("## Critical");
             for (const d of high) {
                 lines.push(`- **${d.text}**`);
             }
-            lines.push("");
         }
         if (medium.length > 0) {
-            lines.push("### Standard");
+            lines.push("## Standard");
             for (const d of medium) {
                 lines.push(`- ${d.text}`);
             }
-            lines.push("");
         }
-    }
-    // Role instructions
-    lines.push("## Role Instructions");
-    lines.push("");
-    for (const roleName of usedRoles) {
-        const role = roles[roleName];
-        if (!role)
-            continue;
-        lines.push(`### ${roleName}`);
+        if (low.length > 0) {
+            lines.push("## Other");
+            for (const d of low) {
+                lines.push(`- ${d.text}`);
+            }
+        }
+        lines.push("</Constraints>");
         lines.push("");
-        if (role.instructions && role.instructions.length > 0) {
-            for (let j = 0; j < role.instructions.length; j++) {
-                lines.push(`${j + 1}. ${role.instructions[j]}`);
+    }
+    // Checkpoints — steps that have checkpoint conditions
+    const stepsWithCheckpoints = plan.steps.filter((s) => s.checkpoints && s.checkpoints.length > 0);
+    if (stepsWithCheckpoints.length > 0) {
+        lines.push("<Checkpoints>");
+        for (const step of stepsWithCheckpoints) {
+            lines.push(`### ${step.id}`);
+            for (const cp of step.checkpoints) {
+                const action = cp.action || "block";
+                lines.push(`- ${cp.assert}: ${cp.message} (${action})`);
             }
         }
-        if (role.post_checks && role.post_checks.length > 0) {
-            lines.push("");
-            lines.push("Post checks: " + role.post_checks.join(", "));
+        lines.push("</Checkpoints>");
+        lines.push("");
+    }
+    // Variables — collect {{var_name}} references from the whole plan
+    const varRefs = collectVariableRefs(plan);
+    if (varRefs.size > 0) {
+        lines.push("<Variables>");
+        for (const varName of varRefs) {
+            const value = variables?.[varName];
+            lines.push(`- \`{{${varName}}}\`: ${value ?? varName}`);
         }
+        lines.push("</Variables>");
         lines.push("");
     }
     let content = lines.join("\n") + "\n";
@@ -136,9 +142,27 @@ export function compileWorkflowToSkill(plan, roles, ir, variables) {
             content = content.replaceAll(`{{${key}}}`, value);
         }
     }
-    const dirName = toKebabCase(plan.name);
+    const dirName = skillName;
     const fileName = join(dirName, "SKILL.md");
-    return { name: plan.name, fileName, dirName, content };
+    return { name: skillName, fileName, dirName, content };
+}
+/** Collect all {{var_name}} references from a workflow plan. */
+function collectVariableRefs(plan) {
+    const refs = new Set();
+    const RE = /\{\{(\w+)\}\}/g;
+    const scan = (s) => {
+        if (!s)
+            return;
+        for (const m of s.matchAll(RE))
+            refs.add(m[1]);
+    };
+    scan(plan.name);
+    scan(plan.description);
+    for (const step of plan.steps) {
+        scan(step.description);
+        scan(step.prompt);
+    }
+    return refs;
 }
 // ── File Operations ────────────────────────────────────────
 export async function writeSkillFiles(results, outputDir) {
@@ -179,4 +203,3 @@ export async function removeSkillFiles(outputDir) {
 function escapeYaml(s) {
     return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
-//# sourceMappingURL=skill-adapter.js.map

package/dist/runtime/workflow-runner.d.ts

@@ -50,4 +50,3 @@ export declare function writeWorkflowScript(result: WorkflowShellResult, outputD
  * Returns number of files removed.
  */
 export declare function removeWorkflowScripts(outputDir: string): Promise<number>;
-//# sourceMappingURL=workflow-runner.d.ts.map

package/dist/runtime/workflow-runner.js

@@ -177,9 +177,6 @@ function generateStepExecution(step, options, plan, isParallel) {
         const condLabel = retrySkipGuard ? "round == 1 (retry_from skip)" : step.run_if;
         lines.push(`  # Step: ${step.id} (run_if: ${condLabel})`);
         lines.push(`  if ${effectiveCondition}; then`);
-        if (step.mode) {
-            lines.push(`    echo '{"active_mode":"${step.mode}","set_at":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","set_by":"workflow:${plan.name}:${step.id}"}' > .dna/mode`);
-        }
         lines.push(`    ${agentCall}`);
         lines.push("  else");
         lines.push(`    echo "[$(date '+%H:%M:%S')] Skipping step: ${step.id} (run_if: ${condLabel}, current round: $ROUND)"`);
@@ -187,9 +184,6 @@ function generateStepExecution(step, options, plan, isParallel) {
     }
     else {
         lines.push(`  # Step: ${step.id}`);
-        if (step.mode) {
-            lines.push(`  echo '{"active_mode":"${step.mode}","set_at":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","set_by":"workflow:${plan.name}:${step.id}"}' > .dna/mode`);
-        }
         if (step.optional) {
             lines.push(`  run_agent "${agent}" '${prompt}' "${step.id}" || {`);
             lines.push(`    STEP_${varId}_STATUS=1`);
@@ -376,13 +370,6 @@ export function compileWorkflowToShell(plan, options) {
         lines.push('echo "All steps passed."');
     }
     lines.push("");
-    // Clean up mode file after workflow completes
-    const hasAnyMode = plan.steps.some((s) => s.mode !== null);
-    if (hasAnyMode) {
-        lines.push("# Clean up mode state");
-        lines.push('rm -f .dna/mode');
-        lines.push("");
-    }
     const script = lines.join("\n") + "\n";
     const fileName = toKebabCase(plan.name) + ".sh";
     return { script, fileName };
@@ -430,4 +417,3 @@ export async function removeWorkflowScripts(outputDir) {
     }
     return removed;
 }
-//# sourceMappingURL=workflow-runner.js.map

package/dist/schema/index.d.ts

@@ -1,2 +1 @@
 export * from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.js

@@ -1,2 +1 @@
 export * from "./types.js";
-//# sourceMappingURL=index.js.map

package/dist/schema/types.d.ts

@@ -79,12 +79,8 @@ export interface RoleDef {
     suppresses_genes?: string[];
     post_checks?: string[];
     instructions?: string[];
-}
-/** Mode definition — coarse-grained enforcement layer above roles */
-export interface ModeDef {
-    description: string;
-    tool_permissions?: ToolPermissions;
-    scope?: ScopeDef;
+    success_criteria?: string[];
+    failure_modes?: string[];
 }
 /** Transition condition between workflow steps */
 export interface TransitionDef {
@@ -121,7 +117,6 @@ export interface CompletionCheck {
 export interface WorkflowStepDef {
     id: string;
     role: string;
-    mode?: string;
     description?: string;
     depends_on?: string[];
     optional?: boolean;
@@ -171,6 +166,16 @@ export interface DNAMetadata {
     gene_count: number;
     epigenetic_marker_count: number;
 }
+/** MCP server dependency declaration */
+export interface MCPServerDef {
+    description: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    timeout?: number;
+    optional?: boolean;
+}
 export interface IntentDNA {
     $schema?: string;
     version: string;
@@ -181,10 +186,10 @@ export interface IntentDNA {
     genes: Record<string, Gene>;
     contexts: Record<string, ContextRegion>;
     roles?: Record<string, RoleDef>;
-    modes?: Record<string, ModeDef>;
     workflow?: WorkflowDef;
     workflows?: Record<string, WorkflowDef>;
     variables?: Record<string, string | VariableDef>;
+    mcp?: Record<string, MCPServerDef>;
     epigenetic: {
         markers: EpigeneticMarker[];
     };
@@ -225,19 +230,29 @@ export interface RoleScopeEntry {
     scope: ScopeDef;
     tool_permissions?: ToolPermissions;
 }
-/** Mode constraint compiled into IR — hook reads .dna/mode and enforces */
-export interface ModeConstraint {
-    mode_name: string;
-    description: string;
-    tool_deny?: string[];
-    scope_write?: string[];
-}
-/** Step checkpoint compiled into IR — hook enforces at mode transition */
+/** Step checkpoint compiled into IR — hook enforces at step transition */
 export interface StepCheckpointIR {
-    step_mode: string;
+    step_role: string;
     step_id: string;
     checkpoints: StepCheckpoint[];
 }
+/** Workflow-partitioned IR — isolates constraints per workflow */
+export interface WorkflowIR {
+    workflow_name: string;
+    namespace: string;
+    step_checkpoints: StepCheckpointIR[];
+    active_roles: string[];
+}
+/** Runtime workflow state written to .dna/state/workflow.json */
+export interface WorkflowState {
+    active: boolean;
+    workflow: string;
+    current_step: string;
+    current_role: string;
+    iteration: number;
+    session_id: string;
+    started_at: string;
+}
 export interface ConstraintIR {
     prompt_directives: PromptDirective[];
     tool_filters: ToolFilter[];
@@ -251,14 +266,13 @@ export interface ConstraintIR {
     role_tool_permissions?: ToolPermissions;
     role_scope?: ScopeDef;
     roles_scope_map?: RoleScopeEntry[];
-    mode_constraints?: ModeConstraint[];
     step_checkpoints?: StepCheckpointIR[];
+    workflows_ir?: WorkflowIR[];
 }
 /** A compiled workflow step with resolved metadata */
 export interface WorkflowStep {
     id: string;
     role: string;
-    mode: string | null;
     description: string;
     optional: boolean;
     run_if: string | null;
@@ -313,4 +327,3 @@ export interface WorkflowPlan {
     compiled_at: string;
     source_workflow: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/schema/types.js

@@ -8,4 +8,3 @@
  *   Layer 4: Epigenetic Markers (experience-driven modulation)
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/schema/validate.d.ts

@@ -18,4 +18,3 @@ export interface ValidationResult {
     warnings?: ValidationError[];
 }
 export declare function validateDNA(dna: IntentDNA): ValidationResult;
-//# sourceMappingURL=validate.d.ts.map

package/dist/schema/validate.js

@@ -186,7 +186,7 @@ function validateRole(name, role, geneNames) {
     }
     return errors;
 }
-function validateWorkflow(workflow, roleNames, pathPrefix, modeNames) {
+function validateWorkflow(workflow, roleNames, pathPrefix) {
     const errors = [];
     const path = pathPrefix ?? "workflow";
     // name required
@@ -225,13 +225,6 @@ function validateWorkflow(workflow, roleNames, pathPrefix, modeNames) {
                 message: `step references unknown role '${step.role}'`,
             });
         }
-        // step.mode optional but must exist in modes if specified
-        if (step.mode && modeNames && modeNames.size > 0 && !modeNames.has(step.mode)) {
-            errors.push({
-                path: `${stepPath}.mode`,
-                message: `step references unknown mode '${step.mode}'`,
-            });
-        }
         // depends_on: check for empty strings in first pass
         for (const dep of step.depends_on ?? []) {
             if (!dep) {
@@ -384,13 +377,6 @@ export function validateDNA(dna) {
     for (const [name, role] of Object.entries(dna.roles ?? {})) {
         errors.push(...validateRole(name, role, geneNames));
     }
-    // Validate modes
-    for (const [name, mode] of Object.entries(dna.modes ?? {})) {
-        const modePath = `modes.${name}`;
-        if (!mode.description) {
-            errors.push({ path: `${modePath}.description`, message: "mode requires 'description'" });
-        }
-    }
     // Validate workflow / workflows (mutually exclusive)
     if (dna.workflow !== undefined && dna.workflows !== undefined) {
         errors.push({
@@ -399,13 +385,41 @@ export function validateDNA(dna) {
         });
     }
     const roleNamesSet = new Set(Object.keys(dna.roles ?? {}));
-    const modeNamesSet = new Set(Object.keys(dna.modes ?? {}));
     if (dna.workflow && !dna.workflows) {
-        errors.push(...validateWorkflow(dna.workflow, roleNamesSet, "workflow", modeNamesSet));
+        errors.push(...validateWorkflow(dna.workflow, roleNamesSet, "workflow"));
     }
     if (dna.workflows && !dna.workflow) {
         for (const [wfName, wfDef] of Object.entries(dna.workflows)) {
-            errors.push(...validateWorkflow(wfDef, roleNamesSet, `workflows.${wfName}`, modeNamesSet));
+            errors.push(...validateWorkflow(wfDef, roleNamesSet, `workflows.${wfName}`));
+        }
+    }
+    // Validate mcp
+    if (dna.mcp) {
+        for (const [name, server] of Object.entries(dna.mcp)) {
+            const mcpPath = `mcp.${name}`;
+            if (!server.description) {
+                errors.push({ path: `${mcpPath}.description`, message: "MCP server requires 'description'" });
+            }
+            // Must have either command or url
+            if (!server.command && !server.url) {
+                errors.push({ path: mcpPath, message: "MCP server requires either 'command' or 'url'" });
+            }
+            // Can't have both command and url
+            if (server.command && server.url) {
+                errors.push({ path: mcpPath, message: "MCP server cannot have both 'command' and 'url'" });
+            }
+            // timeout must be positive
+            if (server.timeout !== undefined && server.timeout <= 0) {
+                errors.push({ path: `${mcpPath}.timeout`, message: "timeout must be positive" });
+            }
+            // env values must be strings
+            if (server.env) {
+                for (const [envKey, envVal] of Object.entries(server.env)) {
+                    if (typeof envVal !== "string") {
+                        errors.push({ path: `${mcpPath}.env.${envKey}`, message: "env value must be a string" });
+                    }
+                }
+            }
         }
     }
     // Validate epigenetic markers
@@ -429,4 +443,3 @@ export function validateDNA(dna) {
     }
     return { valid: errors.length === 0, errors, warnings: warnings.length > 0 ? warnings : undefined };
 }
-//# sourceMappingURL=validate.js.map

package/dist/schema/yaml-parser.d.ts

@@ -9,4 +9,3 @@
  * Zero external dependencies.
  */
 export declare function parseYAML(input: string): unknown;
-//# sourceMappingURL=yaml-parser.d.ts.map

package/dist/schema/yaml-parser.js

@@ -295,4 +295,3 @@ function findNextNonEmptyLine(lines, from) {
     }
     return lines.length;
 }
-//# sourceMappingURL=yaml-parser.js.map