intentdna 1.2.3 → 1.3.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/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,9 @@
+/**
+ * dna setup
+ *
+ * Registers intentdna as a Claude Code plugin.
+ * Auto-detects whether claude CLI is available and prints guidance accordingly.
+ */
+export interface SetupOptions {
+}
+export declare function runSetup(_opts: SetupOptions): Promise<number>;

package/dist/cli/commands/setup.js

@@ -0,0 +1,42 @@
+/**
+ * dna setup
+ *
+ * Registers intentdna as a Claude Code plugin.
+ * Auto-detects whether claude CLI is available and prints guidance accordingly.
+ */
+import { execSync } from "node:child_process";
+export async function runSetup(_opts) {
+    let claudeAvailable = false;
+    try {
+        execSync("claude --version", { stdio: "ignore" });
+        claudeAvailable = true;
+    }
+    catch {
+        // claude CLI not found — fall through to bin mode
+    }
+    if (claudeAvailable) {
+        process.stderr.write("Claude Code CLI detected.\n");
+        process.stderr.write("\n");
+        process.stderr.write("Intent DNA plugin mode:\n");
+        process.stderr.write("  The .claude-plugin/ directory contains plugin.json and hook scripts.\n");
+        process.stderr.write("  To register as a plugin, run:\n");
+        process.stderr.write("\n");
+        let npmRoot = "";
+        try {
+            npmRoot = execSync("npm root -g", { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+        }
+        catch {
+            // ignore
+        }
+        const pluginPath = npmRoot ? `${npmRoot}/intentdna` : "<npm-root>/intentdna";
+        process.stderr.write(`    claude plugin add ${pluginPath}\n`);
+        process.stderr.write("\n");
+        process.stderr.write("  Or run 'dna sync --plugin' to activate hooks via settings.json.\n");
+        process.stderr.write("Intent DNA plugin registered. Run 'dna sync' to activate.\n");
+    }
+    else {
+        process.stderr.write("Claude Code CLI not detected. Using bin mode.\n");
+        process.stderr.write("Run 'dna sync' to register dna-hook in settings.json\n");
+    }
+    return 0;
+}

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/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 (auto-detect mode)
   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)
@@ -355,6 +356,12 @@ async function main() {
             process.exit(code);
             break;
         }
+        case "setup": {
+            const { runSetup } = await import("./commands/setup.js");
+            const code = await runSetup({});
+            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,35 @@ 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 = [];
+            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],
+                    });
+                }
+            }
+            // 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,
+            });
+        }
+    }
     // Sort directives by priority
     const priorityOrder = { high: 0, medium: 1, low: 2 };
     directives.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
@@ -229,5 +258,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/hooks/cli.js

@@ -17,8 +17,8 @@
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { readStdin, writeOutput, silentOutput } from "./protocol.js";
-import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, } from "./enforce.js";
-import { appendAudit } from "./state.js";
+import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, } from "./enforce.js";
+import { appendAudit, readWorkflowState } from "./state.js";
 // ── Constants ──────────────────────────────────────────────
 const DEFAULT_IR_PATH = ".dna/compiled/ir.json";
 const VALID_EVENTS = new Set([
@@ -52,6 +52,24 @@ async function main() {
         return;
     }
     const state = {};
+    // Special handling for Stop — needs async workflow state read
+    if (event === "Stop") {
+        const wfState = await readWorkflowState(projectDir, sessionId);
+        const stopContext = wfState ? {
+            active: wfState.active,
+            workflow: wfState.workflow,
+            current_step: wfState.current_step,
+            current_role: wfState.current_role,
+            started_at: wfState.started_at,
+        } : null;
+        const stopOutput = enforceStop(ir, {
+            cwd: typeof rawInput.cwd === "string" ? rawInput.cwd : undefined,
+            session_id: sessionId,
+            stop_reason: typeof rawInput.stop_reason === "string" ? rawInput.stop_reason : undefined,
+        }, stopContext);
+        writeOutput(stopOutput);
+        return;
+    }
     // Dispatch to enforcement engine
     const output = dispatch(event, ir, rawInput, state);
     writeOutput(output);
@@ -103,7 +121,11 @@ function dispatch(event, ir, input, state) {
         case "Stop":
             return silentOutput(); // DNA doesn't block stops
         case "SessionStart":
-            return silentOutput(); // Placeholder — will initialize DNA state in future
+            return enforceSessionStart(ir, {
+                cwd: typeof input.cwd === "string" ? input.cwd : undefined,
+                session_id: typeof input.sessionId === "string" ? input.sessionId : undefined,
+                trigger: typeof input.trigger === "string" ? input.trigger : undefined,
+            });
         default:
             return silentOutput();
     }

package/dist/hooks/enforce.d.ts

@@ -15,6 +15,12 @@
  */
 import type { ConstraintIR, RoleDef } from "../schema/types.js";
 import type { PreToolUseInput, PostToolUseInput, UserPromptSubmitInput, SubagentStopInput, NotificationInput, HookOutput } from "./protocol.js";
+/** SessionStart input fields */
+export interface SessionStartInput {
+    cwd?: string;
+    session_id?: string;
+    trigger?: string;
+}
 export interface EnforceState {
 }
 /**
@@ -47,6 +53,38 @@ export declare function enforcePreCompact(ir: ConstraintIR): HookOutput;
  * The CLI handles actual audit file writes.
  */
 export declare function enforceNotification(ir: ConstraintIR, input: NotificationInput): HookOutput;
+/**
+ * Initialize DNA state and inject policy summary on session start.
+ * Returns silent if no DNA policies are active.
+ */
+export declare function enforceSessionStart(ir: ConstraintIR, input: SessionStartInput): HookOutput;
+/** Stop enforcement input — includes workflow awareness */
+export interface StopEnforceInput {
+    cwd?: string;
+    session_id?: string;
+    stop_reason?: string;
+}
+/** Workflow state context for stop enforcement */
+export interface StopWorkflowContext {
+    active: boolean;
+    workflow: string;
+    current_step: string;
+    current_role: string;
+    started_at: string;
+}
+/**
+ * Enforce Stop hook — verify workflow checkpoint completion.
+ *
+ * Safety valves (NEVER block):
+ *   - context_limit / context_window stops
+ *   - Stale workflow state (>2h)
+ *   - No active workflow
+ *   - No checkpoints defined
+ *
+ * Block when:
+ *   - Workflow active + unmet checkpoints for current step
+ */
+export declare function enforceStop(ir: ConstraintIR, input: StopEnforceInput, workflowState: StopWorkflowContext | null): HookOutput;
 /** Check if a file path is allowed by a list of write globs (prefix matching). */
 export declare function checkWriteAllowed(filePath: string, allowedGlobs: string[]): boolean;
 /**

package/dist/hooks/enforce.js

@@ -145,6 +145,105 @@ export function enforceNotification(ir, input) {
     }
     return silentOutput();
 }
+// ── SessionStart Enforcement ───────────────────────────────
+/**
+ * Initialize DNA state and inject policy summary on session start.
+ * Returns silent if no DNA policies are active.
+ */
+export function enforceSessionStart(ir, input) {
+    // Check if there's anything meaningful to report
+    const directiveCount = ir.prompt_directives.length;
+    const gateCount = ir.pre_execution_gates.length;
+    const filterCount = ir.tool_filters.length;
+    const roleCount = ir.roles_scope_map?.length ?? 0;
+    const workflowCount = ir.workflows_ir?.length ?? 0;
+    if (directiveCount === 0 && gateCount === 0 && filterCount === 0 && roleCount === 0) {
+        return silentOutput();
+    }
+    // Build policy summary
+    const lines = [
+        "[Intent DNA] Session initialized — active governance:",
+    ];
+    if (ir.source_dna_ids.length > 0) {
+        lines.push(`  Templates: ${ir.source_dna_ids.join(", ")}`);
+    }
+    const stats = [];
+    if (directiveCount > 0)
+        stats.push(`${directiveCount} directives`);
+    if (gateCount > 0)
+        stats.push(`${gateCount} gates`);
+    if (filterCount > 0)
+        stats.push(`${filterCount} filters`);
+    if (roleCount > 0)
+        stats.push(`${roleCount} roles`);
+    if (workflowCount > 0)
+        stats.push(`${workflowCount} workflows`);
+    if (stats.length > 0) {
+        lines.push(`  Enforcement: ${stats.join(", ")}`);
+    }
+    return allowOutput(lines.join("\n"));
+}
+/**
+ * Enforce Stop hook — verify workflow checkpoint completion.
+ *
+ * Safety valves (NEVER block):
+ *   - context_limit / context_window stops
+ *   - Stale workflow state (>2h)
+ *   - No active workflow
+ *   - No checkpoints defined
+ *
+ * Block when:
+ *   - Workflow active + unmet checkpoints for current step
+ */
+export function enforceStop(ir, input, workflowState) {
+    // Safety valve 1: no workflow state → silent
+    if (!workflowState || !workflowState.active) {
+        return silentOutput();
+    }
+    // Safety valve 2: context_limit stops → NEVER block
+    const reason = input.stop_reason ?? "";
+    if (reason.includes("context_limit") || reason.includes("context_window")) {
+        return silentOutput();
+    }
+    // Safety valve 3: user abort → don't block
+    if (reason === "user_abort" || reason === "sigint") {
+        return silentOutput();
+    }
+    // Safety valve 4: stale state (>2h)
+    const STALE_MS = 2 * 60 * 60 * 1000;
+    if (workflowState.started_at) {
+        const age = Date.now() - new Date(workflowState.started_at).getTime();
+        if (age > STALE_MS) {
+            return silentOutput();
+        }
+    }
+    // Check for unmet checkpoints in current step
+    const checkpoints = ir.step_checkpoints ?? [];
+    const currentStepCheckpoints = checkpoints.filter(cp => cp.step_id === workflowState.current_step);
+    // Also check workflows_ir for the active workflow's checkpoints
+    let workflowCheckpoints = currentStepCheckpoints;
+    if (ir.workflows_ir && ir.workflows_ir.length > 0) {
+        const activeWf = ir.workflows_ir.find(w => w.workflow_name === workflowState.workflow);
+        if (activeWf) {
+            const wfStepCps = activeWf.step_checkpoints.filter(cp => cp.step_id === workflowState.current_step);
+            if (wfStepCps.length > 0) {
+                workflowCheckpoints = wfStepCps;
+            }
+        }
+    }
+    if (workflowCheckpoints.length === 0) {
+        return silentOutput(); // No checkpoints for current step
+    }
+    // Build list of blocking checkpoints
+    const blocking = workflowCheckpoints.flatMap(cp => cp.checkpoints.filter(c => (c.action ?? "block") === "block"));
+    if (blocking.length === 0) {
+        return silentOutput();
+    }
+    // Block: workflow active with unmet checkpoints
+    const messages = blocking.map(c => c.message);
+    return blockOutput(`[Intent DNA] Workflow '${workflowState.workflow}' has unmet checkpoints at step '${workflowState.current_step}':\n` +
+        messages.map(m => `  - ${m}`).join("\n"));
+}
 // ── Internal: Layer Enforcement ────────────────────────────
 function enforceRoleScope(rolesScopeMap, input) {
     if (!input.agent_type)

package/dist/hooks/index.d.ts

@@ -4,6 +4,6 @@
  * Public exports for the hook enforcement engine.
  * Used by the `dna-hook` CLI and importable for programmatic use.
  */
-export { type HookEvent, type HookInput, type HookOutput, type HookInputBase, type PreToolUseInput, type PostToolUseInput, type UserPromptSubmitInput, type SubagentStopInput, type PreCompactInput, type NotificationInput, type StopInput, readStdin, writeOutput, allowOutput, blockOutput, escalateOutput, silentOutput, } from "./protocol.js";
-export { type EnforceState, enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, checkWriteAllowed, globToPrefix, evaluateGateCondition, resolveToolTarget, } from "./enforce.js";
+export { type HookEvent, type HookInput, type HookOutput, type HookInputBase, type PreToolUseInput, type PostToolUseInput, type UserPromptSubmitInput, type SubagentStopInput, type PreCompactInput, type NotificationInput, type StopInput, type SessionStartInput as SessionStartHookInput, readStdin, writeOutput, allowOutput, blockOutput, escalateOutput, silentOutput, } from "./protocol.js";
+export { type EnforceState, type SessionStartInput, type StopEnforceInput, type StopWorkflowContext, enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, checkWriteAllowed, globToPrefix, evaluateGateCondition, resolveToolTarget, } from "./enforce.js";
 export { type DNAWorkflowState, type AuditEntry, resolveStateDir, readWorkflowState, writeWorkflowState, clearWorkflowState, appendAudit, } from "./state.js";

package/dist/hooks/index.js

@@ -7,6 +7,6 @@
 // Protocol types and I/O
 export { readStdin, writeOutput, allowOutput, blockOutput, escalateOutput, silentOutput, } from "./protocol.js";
 // Enforcement engine
-export { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, checkWriteAllowed, globToPrefix, evaluateGateCondition, resolveToolTarget, } from "./enforce.js";
+export { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, enforceStop, checkWriteAllowed, globToPrefix, evaluateGateCondition, resolveToolTarget, } from "./enforce.js";
 // State management
 export { resolveStateDir, readWorkflowState, writeWorkflowState, clearWorkflowState, appendAudit, } from "./state.js";

package/dist/hooks/protocol.d.ts

@@ -39,7 +39,10 @@ export interface NotificationInput extends HookInputBase {
 export interface StopInput extends HookInputBase {
     stop_reason?: string;
 }
-export type HookInput = PreToolUseInput | PostToolUseInput | UserPromptSubmitInput | SubagentStopInput | PreCompactInput | NotificationInput | StopInput;
+export interface SessionStartInput extends HookInputBase {
+    trigger?: string;
+}
+export type HookInput = PreToolUseInput | PostToolUseInput | UserPromptSubmitInput | SubagentStopInput | PreCompactInput | NotificationInput | StopInput | SessionStartInput;
 export interface HookOutput {
     continue: boolean;
     decision?: "block" | "allow";

package/dist/schema/types.d.ts

@@ -166,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;
@@ -179,6 +189,7 @@ export interface IntentDNA {
     workflow?: WorkflowDef;
     workflows?: Record<string, WorkflowDef>;
     variables?: Record<string, string | VariableDef>;
+    mcp?: Record<string, MCPServerDef>;
     epigenetic: {
         markers: EpigeneticMarker[];
     };
@@ -225,6 +236,13 @@ export interface StepCheckpointIR {
     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;
@@ -249,6 +267,7 @@ export interface ConstraintIR {
     role_scope?: ScopeDef;
     roles_scope_map?: RoleScopeEntry[];
     step_checkpoints?: StepCheckpointIR[];
+    workflows_ir?: WorkflowIR[];
 }
 /** A compiled workflow step with resolved metadata */
 export interface WorkflowStep {

package/dist/schema/validate.js

@@ -393,6 +393,35 @@ export function validateDNA(dna) {
             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
     for (let i = 0; i < (dna.epigenetic?.markers?.length ?? 0); i++) {
         const marker = dna.epigenetic.markers[i];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intentdna",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "Intent DNA — Declarative policy layer for AI agent behavior",
   "type": "module",
   "main": "dist/index.js",
@@ -33,6 +33,7 @@
   ],
   "files": [
     "dist",
+    ".claude-plugin",
     "README.md",
     "LICENSE"
   ],