intentdna 1.2.1 → 1.2.3

package/dist/hooks/protocol.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Intent DNA — Hook Protocol Types
+ *
+ * TypeScript types for Claude Code hook I/O and stdin/stdout utilities.
+ * All hooks read JSON from stdin and write JSON to stdout.
+ *
+ * Protocol reference: docs/references/cc-source-analysis.md §2
+ */
+export type HookEvent = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "SubagentStop" | "PreCompact" | "Notification" | "Stop" | "SessionStart";
+/** Base fields present in all hook inputs */
+export interface HookInputBase {
+    cwd?: string;
+    sessionId?: string;
+}
+export interface PreToolUseInput extends HookInputBase {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    agent_type?: string;
+}
+export interface PostToolUseInput extends HookInputBase {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_output?: string;
+    agent_type?: string;
+}
+export interface UserPromptSubmitInput extends HookInputBase {
+    prompt?: string;
+}
+export interface SubagentStopInput extends HookInputBase {
+    agent_name?: string;
+    agent_type?: string;
+}
+export interface PreCompactInput extends HookInputBase {
+}
+export interface NotificationInput extends HookInputBase {
+    title?: string;
+    message?: string;
+}
+export interface StopInput extends HookInputBase {
+    stop_reason?: string;
+}
+export type HookInput = PreToolUseInput | PostToolUseInput | UserPromptSubmitInput | SubagentStopInput | PreCompactInput | NotificationInput | StopInput;
+export interface HookOutput {
+    continue: boolean;
+    decision?: "block" | "allow";
+    reason?: string;
+    suppressOutput?: boolean;
+    hookSpecificOutput?: {
+        hookEventName?: string;
+        additionalContext?: string;
+        permissionDecision?: "ask" | "allow" | "deny";
+    };
+}
+/** Create an allow output, optionally injecting text into the conversation. */
+export declare function allowOutput(additionalContext?: string): HookOutput;
+/** Create a block output with reason. */
+export declare function blockOutput(reason: string): HookOutput;
+/** Create an escalate output (ask user for permission). */
+export declare function escalateOutput(reason: string): HookOutput;
+/** Create a silent allow output (no visible output to user). */
+export declare function silentOutput(): HookOutput;
+/**
+ * Read JSON from stdin with timeout protection.
+ * Returns parsed object on success, empty object on failure (fail-open).
+ */
+export declare function readStdin(timeoutMs?: number): Promise<Record<string, unknown>>;
+/**
+ * Write hook output to stdout as JSON.
+ */
+export declare function writeOutput(output: HookOutput): void;

package/dist/hooks/protocol.js

@@ -0,0 +1,91 @@
+/**
+ * Intent DNA — Hook Protocol Types
+ *
+ * TypeScript types for Claude Code hook I/O and stdin/stdout utilities.
+ * All hooks read JSON from stdin and write JSON to stdout.
+ *
+ * Protocol reference: docs/references/cc-source-analysis.md §2
+ */
+// ── Output Helpers ─────────────────────────────────────────
+/** Create an allow output, optionally injecting text into the conversation. */
+export function allowOutput(additionalContext) {
+    if (additionalContext) {
+        return {
+            continue: true,
+            hookSpecificOutput: { additionalContext },
+        };
+    }
+    return { continue: true };
+}
+/** Create a block output with reason. */
+export function blockOutput(reason) {
+    return {
+        continue: false,
+        decision: "block",
+        reason,
+    };
+}
+/** Create an escalate output (ask user for permission). */
+export function escalateOutput(reason) {
+    return {
+        continue: true,
+        hookSpecificOutput: {
+            permissionDecision: "ask",
+            additionalContext: reason,
+        },
+    };
+}
+/** Create a silent allow output (no visible output to user). */
+export function silentOutput() {
+    return { continue: true, suppressOutput: true };
+}
+// ── Stdin/Stdout I/O ───────────────────────────────────────
+/**
+ * Read JSON from stdin with timeout protection.
+ * Returns parsed object on success, empty object on failure (fail-open).
+ */
+export function readStdin(timeoutMs = 5000) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        let settled = false;
+        const finish = (data) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            process.stdin.removeAllListeners("data");
+            process.stdin.removeAllListeners("end");
+            process.stdin.removeAllListeners("error");
+            resolve(data);
+        };
+        const timer = setTimeout(() => finish({}), timeoutMs);
+        process.stdin.on("data", (chunk) => {
+            chunks.push(chunk);
+        });
+        process.stdin.on("end", () => {
+            try {
+                const raw = Buffer.concat(chunks).toString("utf-8").trim();
+                if (!raw) {
+                    finish({});
+                    return;
+                }
+                const parsed = JSON.parse(raw);
+                finish(typeof parsed === "object" && parsed !== null ? parsed : {});
+            }
+            catch {
+                finish({});
+            }
+        });
+        process.stdin.on("error", () => finish({}));
+        // If stdin is already ended (piped and closed)
+        if (process.stdin.readableEnded) {
+            finish({});
+        }
+    });
+}
+/**
+ * Write hook output to stdout as JSON.
+ */
+export function writeOutput(output) {
+    process.stdout.write(JSON.stringify(output) + "\n");
+}

package/dist/hooks/state.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Intent DNA — Hook State System
+ *
+ * Manages `.dna/state/` directory for runtime state tracking:
+ *   - Workflow state (current workflow, step, role — read by hooks)
+ *   - Audit log (violation records in JSON Lines format)
+ *   - Session isolation (per-session state directories)
+ *
+ * All read operations are fail-safe (return null on error, never throw).
+ * All write operations use atomic temp+rename pattern.
+ */
+/** Workflow state written by runtime and read by hooks */
+export interface DNAWorkflowState {
+    active: boolean;
+    workflow: string;
+    current_step: string;
+    current_role: string;
+    iteration: number;
+    session_id: string;
+    started_at: string;
+}
+/** Audit log entry (one per line in JSON Lines format) */
+export interface AuditEntry {
+    timestamp: string;
+    event: string;
+    tool_name?: string;
+    agent_type?: string;
+    message: string;
+    session_id?: string;
+}
+/**
+ * Resolve state directory path.
+ * With session isolation: `.dna/state/sessions/<sessionId>/`
+ * Without: `.dna/state/`
+ */
+export declare function resolveStateDir(projectDir: string, sessionId?: string): string;
+/**
+ * Read current workflow state. Returns null if not found or stale.
+ */
+export declare function readWorkflowState(projectDir: string, sessionId?: string, stalenessMs?: number): Promise<DNAWorkflowState | null>;
+/**
+ * Write workflow state atomically.
+ */
+export declare function writeWorkflowState(projectDir: string, state: DNAWorkflowState, sessionId?: string): Promise<void>;
+/**
+ * Clear workflow state (workflow complete).
+ */
+export declare function clearWorkflowState(projectDir: string, sessionId?: string): Promise<void>;
+/**
+ * Append an entry to the audit log.
+ * Log file: `.dna/audit/violations-YYYY-MM-DD.log` (JSON Lines format)
+ */
+export declare function appendAudit(projectDir: string, entry: AuditEntry): Promise<void>;

package/dist/hooks/state.js

@@ -0,0 +1,93 @@
+/**
+ * Intent DNA — Hook State System
+ *
+ * Manages `.dna/state/` directory for runtime state tracking:
+ *   - Workflow state (current workflow, step, role — read by hooks)
+ *   - Audit log (violation records in JSON Lines format)
+ *   - Session isolation (per-session state directories)
+ *
+ * All read operations are fail-safe (return null on error, never throw).
+ * All write operations use atomic temp+rename pattern.
+ */
+import { readFile, writeFile, rename, mkdir, appendFile, unlink } from "node:fs/promises";
+import { join, dirname } from "node:path";
+// ── Constants ──────────────────────────────────────────────
+const WORKFLOW_FILE = "workflow.json";
+const DEFAULT_STALENESS_MS = 2 * 60 * 60 * 1000; // 2 hours
+// ── Path Resolution ────────────────────────────────────────
+/**
+ * Resolve state directory path.
+ * With session isolation: `.dna/state/sessions/<sessionId>/`
+ * Without: `.dna/state/`
+ */
+export function resolveStateDir(projectDir, sessionId) {
+    const base = join(projectDir, ".dna", "state");
+    if (sessionId) {
+        return join(base, "sessions", sessionId);
+    }
+    return base;
+}
+// ── Workflow State ─────────────────────────────────────────
+/**
+ * Read current workflow state. Returns null if not found or stale.
+ */
+export async function readWorkflowState(projectDir, sessionId, stalenessMs = DEFAULT_STALENESS_MS) {
+    const stateDir = resolveStateDir(projectDir, sessionId);
+    const filePath = join(stateDir, WORKFLOW_FILE);
+    try {
+        const raw = await readFile(filePath, "utf-8");
+        const state = JSON.parse(raw);
+        // Staleness check based on started_at
+        if (stalenessMs > 0 && state.started_at) {
+            const age = Date.now() - new Date(state.started_at).getTime();
+            if (age > stalenessMs)
+                return null;
+        }
+        return state;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write workflow state atomically.
+ */
+export async function writeWorkflowState(projectDir, state, sessionId) {
+    const stateDir = resolveStateDir(projectDir, sessionId);
+    await mkdir(stateDir, { recursive: true });
+    const workflowPath = join(stateDir, WORKFLOW_FILE);
+    await atomicWrite(workflowPath, JSON.stringify(state, null, 2));
+}
+/**
+ * Clear workflow state (workflow complete).
+ */
+export async function clearWorkflowState(projectDir, sessionId) {
+    const stateDir = resolveStateDir(projectDir, sessionId);
+    const workflowPath = join(stateDir, WORKFLOW_FILE);
+    try {
+        await unlink(workflowPath);
+    }
+    catch {
+        // Already gone or never existed
+    }
+}
+// ── Audit Log ──────────────────────────────────────────────
+/**
+ * Append an entry to the audit log.
+ * Log file: `.dna/audit/violations-YYYY-MM-DD.log` (JSON Lines format)
+ */
+export async function appendAudit(projectDir, entry) {
+    const auditDir = join(projectDir, ".dna", "audit");
+    await mkdir(auditDir, { recursive: true });
+    const date = entry.timestamp.slice(0, 10); // YYYY-MM-DD
+    const logPath = join(auditDir, `violations-${date}.log`);
+    await appendFile(logPath, JSON.stringify(entry) + "\n", "utf-8");
+}
+// ── Internal ───────────────────────────────────────────────
+/** Atomic write: write to temp file then rename. */
+async function atomicWrite(filePath, data) {
+    const tmpPath = filePath + ".tmp." + process.pid;
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(tmpPath, data, "utf-8");
+    await rename(tmpPath, filePath);
+}

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./schema/index.js";
 export * from "./compiler/index.js";
 export * from "./runtime/index.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,3 @@
 export * from "./schema/index.js";
 export * from "./compiler/index.js";
 export * from "./runtime/index.js";
-//# sourceMappingURL=index.js.map

package/dist/log/logger.d.ts

@@ -12,4 +12,3 @@ export declare class OutcomeLogger {
     log(outcome: ExecutionOutcome): Promise<void>;
     readAll(): Promise<ExecutionOutcome[]>;
 }
-//# sourceMappingURL=logger.d.ts.map

package/dist/log/logger.js

@@ -33,4 +33,3 @@ export class OutcomeLogger {
         }
     }
 }
-//# sourceMappingURL=logger.js.map

package/dist/runtime/agent-md.d.ts

@@ -53,4 +53,3 @@ export declare function writeAgentMDFiles(results: AgentMDResult[], outputDir: s
  * Returns number of files removed.
  */
 export declare function removeAgentMDFiles(outputDir: string): Promise<number>;
-//# sourceMappingURL=agent-md.d.ts.map

package/dist/runtime/agent-md.js

@@ -50,99 +50,17 @@ function escapeYamlString(s) {
     return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
 /**
- * Render scope section if scope is defined.
+ * Render constraints from ConstraintIR prompt_directives as bullet points.
  */
-function renderScope(scope) {
+function renderConstraints(ir) {
     const lines = [];
-    lines.push("## Scope\n");
-    if (scope.read && scope.read.length > 0) {
-        lines.push(`- Read: ${scope.read.join(", ")}`);
-    }
-    if (scope.write && scope.write.length > 0) {
-        lines.push(`- Write: ${scope.write.join(", ")}`);
+    for (const d of ir.prompt_directives) {
+        lines.push(`- ${d.text}`);
     }
     return lines.join("\n");
 }
 /**
- * Render behavioral guidelines from ConstraintIR prompt_directives.
- */
-function renderGuidelines(ir) {
-    if (ir.prompt_directives.length === 0)
-        return "";
-    const lines = [];
-    lines.push("## Behavioral Guidelines\n");
-    // Group by priority
-    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 === "low");
-    if (high.length > 0) {
-        lines.push("### Critical");
-        for (const d of high) {
-            lines.push(`- **${d.text}**`);
-        }
-        lines.push("");
-    }
-    if (medium.length > 0) {
-        lines.push("### Standard");
-        for (const d of medium) {
-            lines.push(`- ${d.text}`);
-        }
-        lines.push("");
-    }
-    if (low.length > 0) {
-        lines.push("### Preferences");
-        for (const d of low) {
-            lines.push(`- ${d.text}`);
-        }
-        lines.push("");
-    }
-    return lines.join("\n").trimEnd();
-}
-/**
- * Render instructions section as a numbered list.
- */
-function renderInstructions(instructions) {
-    const lines = [];
-    lines.push("## Instructions\n");
-    for (let i = 0; i < instructions.length; i++) {
-        lines.push(`${i + 1}. ${instructions[i]}`);
-    }
-    return lines.join("\n");
-}
-/**
- * Render output schema section.
- */
-function renderOutputSchema(schema) {
-    const lines = [];
-    lines.push("## Output Format\n");
-    if (schema.path) {
-        lines.push(`- Output path: \`${schema.path}\``);
-    }
-    if (schema.format && schema.format !== "markdown") {
-        lines.push(`- Final format: ${schema.format}`);
-    }
-    if (schema.required_sections && schema.required_sections.length > 0) {
-        lines.push("");
-        lines.push("Required sections:");
-        for (const section of schema.required_sections) {
-            lines.push(`- \`## ${section}\``);
-        }
-    }
-    return lines.join("\n");
-}
-/**
- * Render post checks section.
- */
-function renderPostChecks(checks) {
-    const lines = [];
-    lines.push("## Post Checks\n");
-    for (const check of checks) {
-        lines.push(`- ${check}`);
-    }
-    return lines.join("\n");
-}
-/**
- * Render the full markdown body.
+ * Render the full XML body inside Agent_Prompt.
  */
 function renderBody(name, role, ir, options) {
     const prefix = options?.namePrefix ?? "dna-";
@@ -154,35 +72,108 @@ function renderBody(name, role, ir, options) {
     sections.push(SENTINEL_COMMENT);
     sections.push(`<!-- Compiled: ${compiledAt} -->`);
     sections.push("");
-    // Title + description
-    sections.push(`# ${fullName}`);
-    sections.push("");
+    // Open Agent_Prompt
+    sections.push("<Agent_Prompt>");
+    // Role section
+    sections.push("<Role>");
     sections.push(role.description);
-    // Instructions
+    sections.push("</Role>");
+    sections.push("");
+    // Constraints — from IR prompt_directives
+    const hasConstraints = includeDNA && ir && ir.prompt_directives.length > 0;
+    sections.push("<Constraints>");
+    if (hasConstraints) {
+        sections.push(renderConstraints(ir));
+    }
+    sections.push("</Constraints>");
+    sections.push("");
+    // Steps — instructions or fallback
+    sections.push("<Steps>");
     if (role.instructions && role.instructions.length > 0) {
-        sections.push("");
-        sections.push(renderInstructions(role.instructions));
+        for (let i = 0; i < role.instructions.length; i++) {
+            sections.push(`${i + 1}. ${role.instructions[i]}`);
+        }
+    }
+    else {
+        sections.push("Follow the task prompt.");
     }
+    sections.push("</Steps>");
+    sections.push("");
+    // Tool_Usage
+    const allowedTools = role.tool_permissions?.allow && role.tool_permissions.allow.length > 0
+        ? role.tool_permissions.allow.join(", ")
+        : "all";
+    const deniedTools = role.tool_permissions?.deny && role.tool_permissions.deny.length > 0
+        ? role.tool_permissions.deny.join(", ")
+        : "none";
+    sections.push("<Tool_Usage>");
+    sections.push(`- Allowed: ${allowedTools}`);
+    sections.push(`- Denied: ${deniedTools}`);
+    sections.push("</Tool_Usage>");
+    sections.push("");
     // Scope
-    if (role.scope) {
+    const readPaths = role.scope?.read && role.scope.read.length > 0
+        ? role.scope.read.join(", ")
+        : "all files";
+    const writePaths = role.scope?.write && role.scope.write.length > 0
+        ? role.scope.write.join(", ")
+        : "none";
+    sections.push("<Scope>");
+    sections.push(`- Read: ${readPaths}`);
+    sections.push(`- Write: ${writePaths}`);
+    sections.push("</Scope>");
+    // Output_Format — only when structured output_schema present
+    if (role.output_schema && typeof role.output_schema !== "string") {
+        const schema = role.output_schema;
+        const lines = [];
+        if (schema.path) {
+            lines.push(`- Output path: \`${schema.path}\``);
+        }
+        if (schema.format && schema.format !== "markdown") {
+            lines.push(`- Final format: ${schema.format}`);
+        }
+        if (schema.required_sections && schema.required_sections.length > 0) {
+            lines.push("");
+            lines.push("Required sections:");
+            for (const section of schema.required_sections) {
+                lines.push(`- \`## ${section}\``);
+            }
+        }
         sections.push("");
-        sections.push(renderScope(role.scope));
+        sections.push("<Output_Format>");
+        sections.push(lines.join("\n"));
+        sections.push("</Output_Format>");
     }
-    // Behavioral guidelines from IR
-    if (includeDNA && ir && ir.prompt_directives.length > 0) {
+    // Final_Checklist — post_checks
+    if (role.post_checks && role.post_checks.length > 0) {
         sections.push("");
-        sections.push(renderGuidelines(ir));
+        sections.push("<Final_Checklist>");
+        for (const check of role.post_checks) {
+            sections.push(`- ${check}`);
+        }
+        sections.push("</Final_Checklist>");
     }
-    // Output format
-    if (role.output_schema && typeof role.output_schema !== "string") {
+    // Success_Criteria — optional field
+    if (role.success_criteria && role.success_criteria.length > 0) {
         sections.push("");
-        sections.push(renderOutputSchema(role.output_schema));
+        sections.push("<Success_Criteria>");
+        for (const criterion of role.success_criteria) {
+            sections.push(`- ${criterion}`);
+        }
+        sections.push("</Success_Criteria>");
     }
-    // Post checks
-    if (role.post_checks && role.post_checks.length > 0) {
+    // Failure_Modes — optional field
+    if (role.failure_modes && role.failure_modes.length > 0) {
         sections.push("");
-        sections.push(renderPostChecks(role.post_checks));
+        sections.push("<Failure_Modes>");
+        for (const mode of role.failure_modes) {
+            sections.push(`- ${mode}`);
+        }
+        sections.push("</Failure_Modes>");
     }
+    // Close Agent_Prompt
+    sections.push("");
+    sections.push("</Agent_Prompt>");
     return sections.join("\n") + "\n";
 }
 // ── Core Functions ─────────────────────────────────────────
@@ -254,4 +245,3 @@ export async function removeAgentMDFiles(outputDir) {
     }
     return removed;
 }
-//# sourceMappingURL=agent-md.js.map

package/dist/runtime/claude-sdk.d.ts

@@ -48,4 +48,3 @@ export interface PostToolRule {
  * Compile Constraint IR to Claude Agent SDK configuration.
  */
 export declare function compileForClaude(ir: ConstraintIR): ClaudeDNAConfig;
-//# sourceMappingURL=claude-sdk.d.ts.map

package/dist/runtime/claude-sdk.js

@@ -75,4 +75,3 @@ export function compileForClaude(ir) {
         compiled_at: ir.compiled_at,
     };
 }
-//# sourceMappingURL=claude-sdk.js.map

package/dist/runtime/index.d.ts

@@ -1,9 +1,9 @@
 export { compileForClaude } from "./claude-sdk.js";
 export type { ClaudeDNAConfig, PreToolRule, PostToolRule } from "./claude-sdk.js";
-export { compileToHooks, writeHookScripts, removeHookScripts, generateSettingsSnippet, } from "./hooks.js";
-export type { HookScripts, HookCompileOptions } from "./hooks.js";
 export { compileRoleToAgentMD, compileAllRolesToAgentMD, writeAgentMDFiles, removeAgentMDFiles, toKebabCase, } from "./agent-md.js";
 export type { AgentMDOptions, AgentMDResult } from "./agent-md.js";
 export { compileWorkflowToShell, writeWorkflowScript, removeWorkflowScripts, } from "./workflow-runner.js";
 export type { WorkflowShellOptions, WorkflowShellResult } from "./workflow-runner.js";
-//# sourceMappingURL=index.d.ts.map
+export { createCompiledIR, writeCompiledIR, loadCompiledIR, removeCompiledIR, } from "./plugin-adapter.js";
+export type { CompiledIRFile } from "./plugin-adapter.js";
+export { compilePluginSettings, detectEnabledEvents, } from "./settings-adapter.js";

package/dist/runtime/index.js

@@ -1,5 +1,5 @@
 export { compileForClaude } from "./claude-sdk.js";
-export { compileToHooks, writeHookScripts, removeHookScripts, generateSettingsSnippet, } from "./hooks.js";
 export { compileRoleToAgentMD, compileAllRolesToAgentMD, writeAgentMDFiles, removeAgentMDFiles, toKebabCase, } from "./agent-md.js";
 export { compileWorkflowToShell, writeWorkflowScript, removeWorkflowScripts, } from "./workflow-runner.js";
-//# sourceMappingURL=index.js.map
+export { createCompiledIR, writeCompiledIR, loadCompiledIR, removeCompiledIR, } from "./plugin-adapter.js";
+export { compilePluginSettings, detectEnabledEvents, } from "./settings-adapter.js";

package/dist/runtime/markdown.d.ts

@@ -33,4 +33,3 @@ export declare function injectIntoFile(filePath: string, content: string): Promi
  * Returns true if block was found and removed.
  */
 export declare function removeFromFile(filePath: string): Promise<boolean>;
-//# sourceMappingURL=markdown.d.ts.map

package/dist/runtime/markdown.js

@@ -211,4 +211,3 @@ function renderSystemPrompt(ir) {
     }
     return lines.join("\n");
 }
-//# sourceMappingURL=markdown.js.map

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

@@ -0,0 +1,42 @@
+/**
+ * Intent DNA — Plugin Adapter
+ *
+ * Serializes compiled ConstraintIR to .dna/compiled/ir.json for
+ * the Node.js hook runtime (`dna-hook`) to read at enforcement time.
+ *
+ * This is the bridge between compile-time (dna sync) and runtime (hook execution).
+ */
+import type { ConstraintIR, RoleDef } from "../schema/types.js";
+/** Wrapper around ConstraintIR with versioning metadata */
+export interface CompiledIRFile {
+    /** Schema version for forward compatibility */
+    ir_version: 1;
+    /** When the IR was compiled */
+    compiled_at: string;
+    /** Source DNA file IDs */
+    source_dna_ids: string[];
+    /** The compiled Constraint IR */
+    ir: ConstraintIR;
+    /** Cascaded role definitions (for output_schema enforcement) */
+    roles?: Record<string, RoleDef>;
+}
+/**
+ * Create a CompiledIRFile wrapper around a ConstraintIR.
+ */
+export declare function createCompiledIR(ir: ConstraintIR, roles?: Record<string, RoleDef>): CompiledIRFile;
+/**
+ * Write compiled IR to .dna/compiled/ir.json.
+ * Creates the directory if needed.
+ * Returns the absolute path written.
+ */
+export declare function writeCompiledIR(projectDir: string, compiled: CompiledIRFile): Promise<string>;
+/**
+ * Load a CompiledIRFile from disk.
+ * Returns null if not found or invalid.
+ */
+export declare function loadCompiledIR(irPath: string): Promise<CompiledIRFile | null>;
+/**
+ * Remove compiled IR file.
+ * Returns true if removed, false if not found.
+ */
+export declare function removeCompiledIR(projectDir: string): Promise<boolean>;