intentdna 1.2.3 → 1.4.0

package/.claude-plugin/hooks/hooks.json

@@ -0,0 +1,12 @@
+{
+  "hooks": {
+    "PreToolUse": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook PreToolUse", "timeout": 5000 }] }],
+    "PostToolUse": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook PostToolUse", "timeout": 3000 }] }],
+    "UserPromptSubmit": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook UserPromptSubmit", "timeout": 5000 }] }],
+    "SubagentStop": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook SubagentStop", "timeout": 3000 }] }],
+    "PreCompact": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook PreCompact", "timeout": 3000 }] }],
+    "Notification": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook Notification", "timeout": 3000 }] }],
+    "Stop": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook Stop", "timeout": 3000 }] }],
+    "SessionStart": [{ "matcher": "*", "hooks": [{ "type": "command", "command": "dna-hook SessionStart", "timeout": 5000 }] }]
+  }
+}

package/.claude-plugin/marketplace.json

@@ -0,0 +1,12 @@
+{
+  "name": "intentdna",
+  "description": "Declarative policy layer for AI agent governance — compile DNA templates to hooks, agents, and constraints",
+  "plugins": [
+    {
+      "name": "intentdna",
+      "description": "DNA template compilation + runtime enforcement",
+      "version": "1.2.3",
+      "source": "./"
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "intentdna",
+  "version": "0.6.0",
+  "description": "Declarative policy layer for AI agent governance"
+}

package/dist/cli/commands/setup.d.ts

@@ -0,0 +1,21 @@
+/**
+ * dna setup [--scope user|project] [--yes]
+ *
+ * Registers intentdna as a Claude Code plugin:
+ *   1. Detect claude CLI availability
+ *   2. Resolve package path (npm global root)
+ *   3. Confirm with user (unless --yes)
+ *   4. Run: claude plugin marketplace add <path>
+ *   5. Run: claude plugin install intentdna@intentdna --scope <scope>
+ *   6. Verify registration
+ *
+ * Falls back to bin mode guidance when claude CLI is unavailable.
+ *
+ * Reference: OMC plugin registration flow (marketplace add → plugin install)
+ */
+export type SetupScope = "user" | "project";
+export interface SetupOptions {
+    scope: SetupScope;
+    yes: boolean;
+}
+export declare function runSetup(opts: SetupOptions): Promise<number>;

package/dist/cli/commands/setup.js

@@ -0,0 +1,192 @@
+/**
+ * dna setup [--scope user|project] [--yes]
+ *
+ * Registers intentdna as a Claude Code plugin:
+ *   1. Detect claude CLI availability
+ *   2. Resolve package path (npm global root)
+ *   3. Confirm with user (unless --yes)
+ *   4. Run: claude plugin marketplace add <path>
+ *   5. Run: claude plugin install intentdna@intentdna --scope <scope>
+ *   6. Verify registration
+ *
+ * Falls back to bin mode guidance when claude CLI is unavailable.
+ *
+ * Reference: OMC plugin registration flow (marketplace add → plugin install)
+ */
+import { execSync } from "node:child_process";
+import { createInterface } from "node:readline";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { stat } from "node:fs/promises";
+// ── Helpers ───────────────────────────────────────────────
+function log(msg) {
+    process.stderr.write(msg + "\n");
+}
+async function fileExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function confirm(question) {
+    return new Promise((res) => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        rl.question(question + " [Y/n] ", (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            res(a === "" || a === "y" || a === "yes");
+        });
+    });
+}
+/**
+ * Check if claude CLI is available and return its version string.
+ */
+function detectClaudeCLI() {
+    try {
+        return execSync("claude --version 2>/dev/null", { encoding: "utf-8", timeout: 5000 }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the intentdna package root directory.
+ * Priority: npm global install → local package directory (development).
+ */
+async function resolvePackagePath() {
+    // 1. Try npm global root
+    try {
+        const npmRoot = execSync("npm root -g", {
+            encoding: "utf-8",
+            timeout: 5000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        const globalPath = resolve(npmRoot, "intentdna");
+        if (await fileExists(resolve(globalPath, ".claude-plugin", "plugin.json"))) {
+            return globalPath;
+        }
+    }
+    catch { /* not installed globally */ }
+    // 2. Try local package (development mode — this file is inside the package)
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    // In dist: dist/cli/commands/setup.js → ../../.. = package root
+    const localRoot = resolve(thisDir, "..", "..", "..");
+    if (await fileExists(resolve(localRoot, ".claude-plugin", "plugin.json"))) {
+        return localRoot;
+    }
+    return null;
+}
+/**
+ * Check if intentdna is already registered as a plugin.
+ */
+function isPluginRegistered() {
+    try {
+        const result = execSync("claude plugin list 2>/dev/null", {
+            encoding: "utf-8",
+            timeout: 5000,
+        });
+        return result.includes("intentdna");
+    }
+    catch {
+        return false;
+    }
+}
+// ── Main ──────────────────────────────────────────────────
+export async function runSetup(opts) {
+    const scope = opts.scope;
+    // Step 1: Detect claude CLI
+    const claudeVersion = detectClaudeCLI();
+    if (!claudeVersion) {
+        log("Claude Code CLI not detected.");
+        log("");
+        log("Intent DNA can run in bin mode (standalone dna-hook binary):");
+        log("  dna sync              Register dna-hook events in settings.json");
+        log("  dna sync --plugin     Force plugin-style IR generation");
+        log("");
+        log("To use plugin mode, install Claude Code first, then re-run 'dna setup'.");
+        return 0;
+    }
+    log(`Claude Code detected: ${claudeVersion}`);
+    // Step 2: Check if already registered
+    if (isPluginRegistered()) {
+        log("Intent DNA plugin is already registered.");
+        log("Run 'dna sync' to compile and activate your DNA templates.");
+        return 0;
+    }
+    // Step 3: Resolve package path
+    const pkgPath = await resolvePackagePath();
+    if (!pkgPath) {
+        log("Error: Could not find intentdna package with .claude-plugin/ directory.");
+        log("Ensure intentdna is installed: npm install -g intentdna");
+        return 1;
+    }
+    log(`Package found: ${pkgPath}`);
+    log(`Scope: ${scope}`);
+    // Step 4: Confirmation prompt
+    if (!opts.yes) {
+        log("");
+        log("This will:");
+        log(`  1. Register '${pkgPath}' as a plugin marketplace`);
+        log(`  2. Install intentdna plugin (scope: ${scope})`);
+        log("");
+        if (process.stdin.isTTY) {
+            const ok = await confirm("Proceed?");
+            if (!ok) {
+                log("Aborted.");
+                return 0;
+            }
+        }
+    }
+    // Step 5: Register marketplace
+    try {
+        log("");
+        log(`Running: claude plugin marketplace add ${pkgPath}`);
+        execSync(`claude plugin marketplace add "${pkgPath}"`, {
+            encoding: "utf-8",
+            timeout: 30000,
+            stdio: ["inherit", "pipe", "pipe"],
+        });
+        log("Marketplace registered.");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`Warning: marketplace add failed: ${msg}`);
+        log("You may need to run manually:");
+        log(`  claude plugin marketplace add "${pkgPath}"`);
+        // Continue — install may still work if marketplace was already added
+    }
+    // Step 6: Install plugin
+    try {
+        const installCmd = `claude plugin install intentdna@intentdna --scope ${scope}`;
+        log(`Running: ${installCmd}`);
+        execSync(installCmd, {
+            encoding: "utf-8",
+            timeout: 30000,
+            stdio: ["inherit", "pipe", "pipe"],
+        });
+        log("Plugin installed.");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log(`Warning: plugin install failed: ${msg}`);
+        log("You may need to run manually:");
+        log(`  claude plugin install intentdna@intentdna --scope ${scope}`);
+        return 1;
+    }
+    // Step 7: Verify
+    if (isPluginRegistered()) {
+        log("");
+        log("Intent DNA plugin registered successfully.");
+        log("Run 'dna sync' to compile and activate your DNA templates.");
+        return 0;
+    }
+    else {
+        log("");
+        log("Plugin install completed but verification failed.");
+        log("Try: claude plugin list");
+        return 1;
+    }
+}

package/dist/cli/commands/sync.d.ts

@@ -28,4 +28,16 @@ export interface SyncOptions {
     remove: boolean;
     plugin?: boolean;
 }
+/**
+ * Detect whether intentdna is running as a Claude Code plugin or standalone binary.
+ *
+ * Plugin mode: claude plugin system manages hook dispatch
+ *   → generate ir.json + agents + skills + .mcp.json
+ *   → do NOT write settings.json (hooks provided by plugin framework)
+ *
+ * Bin mode: fallback when plugin not installed
+ *   → same as above
+ *   → ALSO write settings.json to register dna-hook events
+ */
+export declare function detectMode(): Promise<"plugin" | "bin">;
 export declare function runSync(opts: SyncOptions): Promise<number>;

package/dist/cli/commands/sync.js

@@ -25,6 +25,33 @@ import { createCompiledIR, writeCompiledIR } from "../../runtime/plugin-adapter.
 import { cascadeDNA } from "../../compiler/cascade.js";
 import { EvolutionEngine } from "../../evolution/index.js";
 const VALID_TARGETS = ["claude-md", "soul-md", "cursorrules", "system-prompt"];
+/**
+ * Detect whether intentdna is running as a Claude Code plugin or standalone binary.
+ *
+ * Plugin mode: claude plugin system manages hook dispatch
+ *   → generate ir.json + agents + skills + .mcp.json
+ *   → do NOT write settings.json (hooks provided by plugin framework)
+ *
+ * Bin mode: fallback when plugin not installed
+ *   → same as above
+ *   → ALSO write settings.json to register dna-hook events
+ */
+export async function detectMode() {
+    // Check: is intentdna registered as a Claude Code plugin?
+    try {
+        const { execSync } = await import("node:child_process");
+        const result = execSync("claude plugin list 2>/dev/null", {
+            encoding: "utf-8",
+            timeout: 5000,
+        });
+        if (result.includes("intentdna"))
+            return "plugin";
+    }
+    catch {
+        // claude CLI not available or plugin not registered
+    }
+    return "bin";
+}
 async function fileExists(path) {
     try {
         await stat(path);
@@ -245,6 +272,14 @@ export async function runSync(opts) {
             process.stderr.write(`Auto-detect: Claude Code → CLAUDE.md + agents + skills + settings\n`);
         }
     }
+    // Auto-detect plugin vs bin mode if --plugin not explicitly set
+    if (!opts.remove && opts.plugin === undefined) {
+        const mode = await detectMode();
+        if (mode === "plugin") {
+            opts.plugin = true;
+            process.stderr.write("Auto-detect: plugin mode (intentdna registered as Claude Code plugin)\n");
+        }
+    }
     // Handle --remove
     if (opts.remove) {
         if (!opts.inject && !opts.hooksDir && !opts.agentsDir && !opts.workflowDir) {
@@ -340,34 +375,37 @@ export async function runSync(opts) {
             }
             trackedOutputs.push(resolve(opts.inject));
         }
-        // Step 3.5: Plugin mode — write IR + register dna-hook
-        if (opts.plugin) {
+        // Step 3.5: Write compiled IR (needed for both plugin and bin mode)
+        {
             const cwd = process.cwd();
-            // Write compiled IR
             const dnas = await Promise.all(expandedFiles.map(loadDNA));
             const cascadedForIR = cascadeDNA(dnas);
             const roles = cascadedForIR.roles;
             const compiled = createCompiledIR(ir, roles);
             const irPath = await writeCompiledIR(cwd, compiled);
-            process.stderr.write(`Plugin: wrote ${irPath}\n`);
+            process.stderr.write(`Wrote compiled IR: ${irPath}\n`);
             trackedOutputs.push(resolve(irPath));
-            // Register dna-hook events in settings.json
-            if (opts.settingsPath) {
-                const enabledEvents = detectEnabledEvents(ir);
-                if (enabledEvents.length > 0) {
-                    const pluginSettings = compilePluginSettings(enabledEvents);
-                    await mergeSettingsFile(pluginSettings, opts.settingsPath);
-                    process.stderr.write(`Plugin: registered ${enabledEvents.length} dna-hook event(s) in ${opts.settingsPath}\n`);
-                    trackedOutputs.push(resolve(opts.settingsPath));
-                }
-            }
             // Clean up old bash hooks if they exist
             const oldHooksDir = resolve(cwd, ".claude", "hooks");
             const removed = await removeLegacyBashHooks(oldHooksDir);
             if (removed > 0) {
-                process.stderr.write(`Plugin: cleaned ${removed} legacy bash hook(s) from ${oldHooksDir}\n`);
+                process.stderr.write(`Cleaned ${removed} legacy bash hook(s) from ${oldHooksDir}\n`);
+            }
+        }
+        // Step 3.6: Register hooks in settings.json (bin mode only)
+        // Plugin mode: hooks managed by plugin framework — skip settings.json
+        if (!opts.plugin && opts.settingsPath) {
+            const enabledEvents = detectEnabledEvents(ir);
+            if (enabledEvents.length > 0) {
+                const pluginSettings = compilePluginSettings(enabledEvents);
+                await mergeSettingsFile(pluginSettings, opts.settingsPath);
+                process.stderr.write(`Bin mode: registered ${enabledEvents.length} hook event(s) in ${opts.settingsPath}\n`);
+                trackedOutputs.push(resolve(opts.settingsPath));
             }
         }
+        else if (opts.plugin && opts.settingsPath) {
+            process.stderr.write(`Plugin mode: hooks managed by plugin framework (skipping settings.json)\n`);
+        }
         // Step 5: Generate agent MD files
         if (opts.agentsDir) {
             // Clean stale DNA-managed agents before regenerating
@@ -448,6 +486,20 @@ export async function runSync(opts) {
             }
             const configPath = await autoDetectDNA();
             const variables = await resolveVariables(rawVars, configPath);
+            // Step 8: Generate .claude/.mcp.json from MCP dependencies (inside skillsDir block, shares variables)
+            {
+                const mcpDeps = {};
+                for (const d of dnas) {
+                    if (d.mcp)
+                        Object.assign(mcpDeps, d.mcp);
+                }
+                if (Object.keys(mcpDeps).length > 0) {
+                    const cwd = process.cwd();
+                    const mcpJsonPath = resolve(cwd, ".claude", ".mcp.json");
+                    await writeMCPConfig(mcpDeps, mcpJsonPath, variables);
+                    process.stderr.write(`MCP: wrote ${Object.keys(mcpDeps).length} server(s) to ${mcpJsonPath}\n`);
+                }
+            }
             if (Object.keys(workflows).length === 0) {
                 process.stderr.write("No workflow defined — no skills to generate\n");
             }
@@ -488,3 +540,51 @@ export async function runSync(opts) {
         return 1;
     }
 }
+/**
+ * Write MCP server configuration to .claude/.mcp.json.
+ * Merges with existing config — DNA-declared servers are added/updated,
+ * but existing user-configured servers are NOT overwritten.
+ */
+async function writeMCPConfig(mcpDeps, mcpJsonPath, variables) {
+    // Read existing .mcp.json
+    let existing = {};
+    try {
+        const raw = await readFile(mcpJsonPath, "utf-8");
+        existing = JSON.parse(raw);
+    }
+    catch { /* doesn't exist yet */ }
+    const mcpServers = (existing.mcpServers ?? {});
+    for (const [name, server] of Object.entries(mcpDeps)) {
+        // Don't overwrite existing user-configured servers
+        if (mcpServers[name])
+            continue;
+        const entry = {};
+        if (server.command) {
+            entry.command = server.command;
+            if (server.args)
+                entry.args = server.args;
+        }
+        if (server.url) {
+            entry.url = server.url;
+        }
+        if (server.env) {
+            // Substitute {{variable}} placeholders
+            const resolvedEnv = {};
+            for (const [k, v] of Object.entries(server.env)) {
+                resolvedEnv[k] = substituteVariables(v, variables);
+            }
+            entry.env = resolvedEnv;
+        }
+        if (server.timeout) {
+            entry.timeout = server.timeout;
+        }
+        mcpServers[name] = entry;
+    }
+    existing.mcpServers = mcpServers;
+    await mkdir(dirname(mcpJsonPath), { recursive: true });
+    await writeFileAsync(mcpJsonPath, JSON.stringify(existing, null, 2) + "\n", "utf-8");
+}
+/** Replace {{var}} placeholders with resolved variable values */
+function substituteVariables(template, vars) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}

package/dist/cli/commands/verify.d.ts

@@ -11,6 +11,7 @@
  */
 export interface VerifyOptions {
     lockFile: string;
+    stats?: boolean;
 }
 export interface LockFileEntry {
     sha256: string;

package/dist/cli/commands/verify.js

@@ -11,6 +11,7 @@
  */
 import { readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
+import { readTraces } from "../../hooks/state.js";
 // ── Helpers ────────────────────────────────────────────────
 export function sha256(content) {
     return createHash("sha256").update(content, "utf-8").digest("hex");
@@ -53,6 +54,10 @@ export async function verifyLock(lock) {
 }
 // ── CLI entry ──────────────────────────────────────────────
 export async function runVerify(opts) {
+    // Handle --stats mode
+    if (opts.stats) {
+        return runStats();
+    }
     // Read lock file
     let raw;
     try {
@@ -99,3 +104,67 @@ export async function runVerify(opts) {
         return 0;
     }
 }
+// ── Stats Mode ────────────────────────────────────────────
+async function runStats() {
+    const cwd = process.cwd();
+    const entries = await readTraces(cwd, 1); // last 24h
+    if (entries.length === 0) {
+        process.stderr.write("No trace data found (last 24h).\n");
+        process.stderr.write("Traces are written to .dna/state/trace/ during hook execution.\n");
+        return 0;
+    }
+    // Group by event
+    const byEvent = new Map();
+    for (const e of entries) {
+        const list = byEvent.get(e.event) ?? [];
+        list.push(e);
+        byEvent.set(e.event, list);
+    }
+    process.stderr.write("Hook call statistics (last 24h):\n");
+    for (const [event, list] of byEvent) {
+        const blocks = list.filter(e => e.decision === "block").length;
+        const warns = list.filter(e => e.decision === "warn").length;
+        const avgMs = list.reduce((sum, e) => sum + e.duration_ms, 0) / list.length;
+        const parts = [`${list.length} calls`];
+        if (blocks > 0)
+            parts.push(`${blocks} blocks`);
+        if (warns > 0)
+            parts.push(`${warns} warns`);
+        parts.push(`avg ${avgMs.toFixed(1)}ms`);
+        process.stderr.write(`  ${event.padEnd(18)} ${parts.join(", ")}\n`);
+    }
+    // Workflow stats
+    const withWorkflow = entries.filter(e => e.workflow);
+    if (withWorkflow.length > 0) {
+        const byWorkflow = new Map();
+        for (const e of withWorkflow) {
+            const key = e.workflow;
+            const list = byWorkflow.get(key) ?? [];
+            list.push(e);
+            byWorkflow.set(key, list);
+        }
+        process.stderr.write("\nWorkflow statistics:\n");
+        for (const [wf, list] of byWorkflow) {
+            const steps = new Set(list.map(e => e.step).filter(Boolean));
+            const blocks = list.filter(e => e.decision === "block").length;
+            process.stderr.write(`  ${wf}: ${list.length} tool calls, ${steps.size} steps, ${blocks} blocks\n`);
+        }
+    }
+    // Block reasons TOP 3
+    const blockEntries = entries.filter(e => e.decision === "block");
+    if (blockEntries.length > 0) {
+        const reasons = new Map();
+        for (const e of blockEntries) {
+            const key = `${e.event}:${e.tool_name ?? "unknown"}`;
+            reasons.set(key, (reasons.get(key) ?? 0) + 1);
+        }
+        const sorted = [...reasons.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3);
+        process.stderr.write("\nBlock reasons TOP 3:\n");
+        let rank = 0;
+        for (const [reason, count] of sorted) {
+            rank++;
+            process.stderr.write(`  ${rank}. ${reason} x ${count}\n`);
+        }
+    }
+    return 0;
+}

package/dist/cli/index.js

@@ -17,6 +17,7 @@ const HELP = `Intent DNA CLI v0.3.0
 Usage: dna <command> [options]
 
 Commands:
+  setup         Register intentdna as a Claude Code plugin (--scope user|project, --yes)
   guard         Zero-config guardrails — detect environment, apply safety rules
   sync          Compile + inject DNA into target file (CLAUDE.md, SOUL.md, etc.)
   verify        Verify synced files match .dna/lock checksums (drift detection)
@@ -52,6 +53,7 @@ Examples:
   dna sync --remove --inject CLAUDE.md --hooks .claude/hooks --agents .claude/agents
   dna verify                          Verify synced files against .dna/lock
   dna verify --lock /path/to/.dna/lock
+  dna verify --stats                  Show hook call statistics (last 24h)
   dna import .                  Import existing harness configs into DNA format
   dna run --dna my.dna.json --workflow dev-pipeline --task P5.8
   dna run --dna my.dna.json --workflow dev-pipeline --task P5.8 --dry-run
@@ -119,6 +121,7 @@ async function main() {
                 args: rest,
                 options: {
                     lock: { type: "string", default: ".dna/lock" },
+                    stats: { type: "boolean", default: false },
                 },
                 allowPositionals: true,
                 strict: false,
@@ -126,6 +129,7 @@ async function main() {
             const { runVerify } = await import("./commands/verify.js");
             const code = await runVerify({
                 lockFile: verifyValues.lock,
+                stats: verifyValues.stats,
             });
             process.exit(code);
             break;
@@ -355,6 +359,28 @@ async function main() {
             process.exit(code);
             break;
         }
+        case "setup": {
+            const { values: setupValues } = parseArgs({
+                args: rest,
+                options: {
+                    scope: { type: "string", short: "s", default: "user" },
+                    yes: { type: "boolean", short: "y", default: false },
+                },
+                strict: false,
+            });
+            const setupScope = setupValues.scope;
+            if (setupScope !== "user" && setupScope !== "project") {
+                process.stderr.write(`Error: --scope must be 'user' or 'project', got '${setupScope}'\n`);
+                process.exit(2);
+            }
+            const { runSetup } = await import("./commands/setup.js");
+            const code = await runSetup({
+                scope: setupScope,
+                yes: setupValues.yes,
+            });
+            process.exit(code);
+            break;
+        }
         default:
             process.stderr.write(`Unknown command: ${command}\n\n`);
             process.stderr.write(HELP);

package/dist/compiler/compile.js

@@ -212,6 +212,45 @@ export function compileDNA(activated, cascaded) {
             }
         }
     }
+    // Build workflows_ir: per-workflow partitioned view with namespace context
+    const workflowsIR = [];
+    if (cascaded?.workflows) {
+        for (const [wfKey, wf] of Object.entries(cascaded.workflows)) {
+            const wfStepCheckpoints = [];
+            const activeRoles = [];
+            const handoffChain = [];
+            for (const step of wf.steps ?? []) {
+                if (!activeRoles.includes(step.role)) {
+                    activeRoles.push(step.role);
+                }
+                if (step.checkpoints && step.checkpoints.length > 0) {
+                    wfStepCheckpoints.push({
+                        step_role: step.role,
+                        step_id: step.id,
+                        checkpoints: [...step.checkpoints],
+                    });
+                }
+                // Collect handoff chain entries
+                if (step.handoff) {
+                    handoffChain.push({
+                        step_id: step.id,
+                        produces: step.handoff.produces,
+                        consumes: step.handoff.consumes,
+                    });
+                }
+            }
+            // Derive namespace from workflow key: "ns_wfname" → "ns", "wfname" → ""
+            const underscoreIdx = wfKey.indexOf("_");
+            const namespace = underscoreIdx > 0 ? wfKey.slice(0, underscoreIdx) : "";
+            workflowsIR.push({
+                workflow_name: wfKey,
+                namespace,
+                step_checkpoints: wfStepCheckpoints,
+                active_roles: activeRoles,
+                handoff_chain: handoffChain,
+            });
+        }
+    }
     // Sort directives by priority
     const priorityOrder = { high: 0, medium: 1, low: 2 };
     directives.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
@@ -229,5 +268,6 @@ export function compileDNA(activated, cascaded) {
         role_scope: roleScope,
         roles_scope_map: rolesScopeMap.length > 0 ? rolesScopeMap : undefined,
         step_checkpoints: stepCheckpoints.length > 0 ? stepCheckpoints : undefined,
+        workflows_ir: workflowsIR.length > 0 ? workflowsIR : undefined,
     };
 }

package/dist/compiler/workflow.js

@@ -173,6 +173,7 @@ function toWorkflowStep(def) {
         prompt: def.prompt ?? null,
         completion: def.completion && def.completion.length > 0 ? [...def.completion] : null,
         checkpoints: def.checkpoints && def.checkpoints.length > 0 ? [...def.checkpoints] : null,
+        handoff: def.handoff ?? null,
     };
 }
 /**