intentdna 1.5.2 → 1.5.4

package/dist/mcp/tools-compile.js

@@ -0,0 +1,214 @@
+/**
+ * Intent DNA — MCP Compile Tools (G3)
+ *
+ * Tools for compiling and managing DNA via MCP:
+ *   - dna_compile: Compile DNA config to Constraint IR
+ *   - dna_validate: Validate a DNA config file
+ *   - dna_sync: Run full sync pipeline (compile + inject + hooks)
+ */
+import { resolve } from "node:path";
+import { stat } from "node:fs/promises";
+import { loadDNA, compileFromFiles } from "../compiler/index.js";
+import { textResult, errorResult } from "./server.js";
+async function fileExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Auto-detect DNA config files in the project directory. */
+async function detectConfigs(projectDir) {
+    const { readdir } = await import("node:fs/promises");
+    // Multi-config: .dna/configs/*.yaml
+    const configsDir = resolve(projectDir, ".dna", "configs");
+    try {
+        const files = await readdir(configsDir);
+        const yamls = files
+            .filter(f => f.endsWith(".yaml") || f.endsWith(".yml"))
+            .sort()
+            .map(f => resolve(configsDir, f));
+        if (yamls.length > 0)
+            return yamls;
+    }
+    catch { /* dir doesn't exist */ }
+    // Legacy single-config
+    const candidates = [
+        ".dna/config.yaml", ".dna/config.yml", ".dna/config.json",
+        ".dna.yaml", ".dna.yml", ".dna.json",
+    ];
+    for (const name of candidates) {
+        const path = resolve(projectDir, name);
+        if (await fileExists(path))
+            return [path];
+    }
+    return [];
+}
+export function createCompileTools(projectDir) {
+    return [
+        // ── dna_validate ─────────────────────────────────────
+        {
+            name: "dna_validate",
+            description: "Validate a DNA config file for schema errors without compiling",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    config_path: { type: "string", description: "Path to DNA config (auto-detected if omitted)" },
+                },
+            },
+            handler: async (args) => {
+                const configPath = typeof args.config_path === "string"
+                    ? resolve(projectDir, args.config_path)
+                    : undefined;
+                const files = configPath ? [configPath] : await detectConfigs(projectDir);
+                if (files.length === 0)
+                    return errorResult("No DNA config files found.");
+                const results = [];
+                let allValid = true;
+                for (const file of files) {
+                    try {
+                        // loadDNA calls validateDNA internally — throws on invalid
+                        await loadDNA(file);
+                        results.push(`${file}: valid`);
+                    }
+                    catch (err) {
+                        allValid = false;
+                        results.push(`${file}: INVALID — ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+                results.unshift(allValid ? "All configs valid." : "Validation errors found.");
+                return textResult(results.join("\n"));
+            },
+        },
+        // ── dna_compile ──────────────────────────────────────
+        {
+            name: "dna_compile",
+            description: "Compile DNA config(s) to Constraint IR and return a summary of the compiled constraints",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    config_path: { type: "string", description: "Path to DNA config (auto-detected if omitted)" },
+                    context: { type: "string", description: "Active context name (e.g., 'work', 'personal')" },
+                    role: { type: "string", description: "Active role name" },
+                },
+            },
+            handler: async (args) => {
+                const configPath = typeof args.config_path === "string"
+                    ? resolve(projectDir, args.config_path)
+                    : undefined;
+                const files = configPath ? [configPath] : await detectConfigs(projectDir);
+                if (files.length === 0)
+                    return errorResult("No DNA config files found.");
+                try {
+                    const ir = await compileFromFiles(files, {
+                        context: typeof args.context === "string" ? args.context : undefined,
+                        role: typeof args.role === "string" ? args.role : undefined,
+                    });
+                    const lines = [
+                        `Compiled from: ${ir.source_dna_ids.join(", ")}`,
+                        `  Directives: ${ir.prompt_directives.length}`,
+                        `  Gates: ${ir.pre_execution_gates.length}`,
+                        `  Filters: ${ir.tool_filters.length}`,
+                        `  Validators: ${ir.post_execution_validators.length}`,
+                    ];
+                    if (ir.roles_scope_map?.length) {
+                        lines.push(`  Roles: ${ir.roles_scope_map.map(r => r.role_name).join(", ")}`);
+                    }
+                    if (ir.workflows_ir?.length) {
+                        lines.push(`  Workflows: ${ir.workflows_ir.map(w => w.workflow_name).join(", ")}`);
+                        for (const wf of ir.workflows_ir) {
+                            lines.push(`    ${wf.workflow_name}: ${wf.active_roles.length} roles, ${wf.step_checkpoints.length} checkpoints`);
+                            if (wf.step_enforce_rules?.length) {
+                                lines.push(`      Enforce rules: ${wf.step_enforce_rules.length}`);
+                            }
+                        }
+                    }
+                    return textResult(lines.join("\n"));
+                }
+                catch (err) {
+                    return errorResult(`Compilation failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            },
+        },
+        // ── dna_sync ─────────────────────────────────────────
+        {
+            name: "dna_sync",
+            description: "Run full DNA sync pipeline: compile + inject CLAUDE.md + generate agents/skills/hooks. Equivalent to CLI `dna sync`.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    evolve: { type: "boolean", description: "Run evolution engine before compiling (default false)" },
+                    context: { type: "string", description: "Active context name" },
+                    role: { type: "string", description: "Active role name" },
+                },
+            },
+            handler: async (args) => {
+                // Import sync command dynamically to avoid circular deps
+                const { runSync, autoDetectConfigs: detectAll } = await import("../cli/commands/sync.js");
+                const files = await detectAll();
+                if (files.length === 0)
+                    return errorResult("No DNA config files found.");
+                const exitCode = await runSync({
+                    files,
+                    target: "claude-md",
+                    inject: resolve(projectDir, "CLAUDE.md"),
+                    evolve: typeof args.evolve === "boolean" ? args.evolve : false,
+                    context: typeof args.context === "string" ? args.context : undefined,
+                    agentsDir: resolve(projectDir, ".claude", "agents"),
+                    skillsDir: resolve(projectDir, ".claude", "skills"),
+                    settingsPath: resolve(projectDir, ".claude", "settings.json"),
+                    remove: false,
+                });
+                if (exitCode === 0) {
+                    return textResult("Sync completed successfully.");
+                }
+                return errorResult(`Sync failed with exit code ${exitCode}.`);
+            },
+        },
+        // ── dna_generate ─────────────────────────────────────
+        {
+            name: "dna_generate",
+            description: "Generate a DNA config from a natural-language description. Lists matching templates or provides guidance for custom configs.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    description: { type: "string", description: "Natural-language description of the desired DNA config" },
+                },
+                required: ["description"],
+            },
+            handler: async (args) => {
+                const description = String(args.description);
+                // List available templates
+                const { readdir } = await import("node:fs/promises");
+                const { resolve: resolvePath, dirname } = await import("node:path");
+                const { fileURLToPath } = await import("node:url");
+                let templates = [];
+                try {
+                    const thisDir = dirname(fileURLToPath(import.meta.url));
+                    const templatesDir = resolvePath(thisDir, "..", "templates");
+                    const files = await readdir(templatesDir);
+                    templates = files.filter(f => f.endsWith(".yaml")).map(f => f.replace(".yaml", ""));
+                }
+                catch { /* templates dir not found */ }
+                const lines = [
+                    `Generate DNA for: "${description}"`,
+                    "",
+                    "Options:",
+                    `  1. Use a template: dna init --template <name>`,
+                    `  2. Generate prompt: dna generate "${description}" --output .dna/prompt.md`,
+                    `  3. Create manually: write .dna/config.yaml following the DNA schema`,
+                    "",
+                ];
+                if (templates.length > 0) {
+                    lines.push(`Available templates (${templates.length}):`);
+                    for (const t of templates) {
+                        lines.push(`  - ${t}`);
+                    }
+                }
+                return textResult(lines.join("\n"));
+            },
+        },
+    ];
+}

package/dist/mcp/tools-enforce.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Intent DNA — MCP Enforce Tools (U2)
+ *
+ * Provides enforcement via MCP server with in-memory IR cache.
+ * Zero cold-start: IR is loaded once and cached with mtime-based invalidation.
+ *
+ * Tools:
+ *   - dna_enforce: Run enforcement for a hook event (PreToolUse, PostToolUse, etc.)
+ */
+import type { ConstraintIR, RoleDef } from "../schema/types.js";
+import type { ToolDef } from "./server.js";
+/** In-memory IR cache with mtime-based invalidation. */
+export declare class IRCache {
+    private ir;
+    private roles;
+    private lastMtime;
+    private irPath;
+    constructor(projectDir: string);
+    /** Get cached IR, reloading from disk only if file changed. */
+    get(): Promise<{
+        ir: ConstraintIR;
+        roles?: Record<string, RoleDef>;
+    } | null>;
+    /** Invalidate the cache (e.g., after dna sync). */
+    invalidate(): void;
+}
+export declare function createEnforceTools(projectDir: string): ToolDef[];

package/dist/mcp/tools-enforce.js

@@ -0,0 +1,178 @@
+/**
+ * Intent DNA — MCP Enforce Tools (U2)
+ *
+ * Provides enforcement via MCP server with in-memory IR cache.
+ * Zero cold-start: IR is loaded once and cached with mtime-based invalidation.
+ *
+ * Tools:
+ *   - dna_enforce: Run enforcement for a hook event (PreToolUse, PostToolUse, etc.)
+ */
+import { resolve } from "node:path";
+import { stat, readFile } from "node:fs/promises";
+import { enforcePreToolUse, enforcePostToolUse, enforceUserPromptSubmit, enforceSubagentStop, enforcePreCompact, enforceNotification, enforceSessionStart, } from "../hooks/enforce.js";
+import { textResult, errorResult } from "./server.js";
+// ── IR Cache ────────────────────────────────────────────────
+/** In-memory IR cache with mtime-based invalidation. */
+export class IRCache {
+    ir = null;
+    roles = undefined;
+    lastMtime = 0;
+    irPath;
+    constructor(projectDir) {
+        this.irPath = resolve(projectDir, ".dna", "compiled", "ir.json");
+    }
+    /** Get cached IR, reloading from disk only if file changed. */
+    async get() {
+        try {
+            const fileStat = await stat(this.irPath);
+            const mtime = fileStat.mtimeMs;
+            const cachedIR = this.ir;
+            if (cachedIR && mtime === this.lastMtime) {
+                return { ir: cachedIR, roles: this.roles };
+            }
+            // File changed or first load — read from disk
+            const raw = await readFile(this.irPath, "utf-8");
+            const data = JSON.parse(raw);
+            if (data.ir_version && data.ir) {
+                const ir = data.ir;
+                this.ir = ir;
+                this.roles = data.roles;
+                this.lastMtime = mtime;
+                return { ir, roles: this.roles };
+            }
+            // Direct ConstraintIR format (backward compat)
+            if (data.compiled_at && data.source_dna_ids) {
+                const ir = data;
+                this.ir = ir;
+                this.roles = undefined;
+                this.lastMtime = mtime;
+                return { ir };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Invalidate the cache (e.g., after dna sync). */
+    invalidate() {
+        this.ir = null;
+        this.roles = undefined;
+        this.lastMtime = 0;
+    }
+}
+const VALID_EVENTS = new Set([
+    "PreToolUse", "PostToolUse", "UserPromptSubmit",
+    "SubagentStop", "PreCompact", "Notification", "SessionStart",
+]);
+function dispatchEnforce(event, ir, input, roles) {
+    switch (event) {
+        case "PreToolUse":
+            return enforcePreToolUse(ir, {
+                tool_name: String(input.tool_name ?? ""),
+                tool_input: (input.tool_input ?? {}),
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+                cwd: typeof input.cwd === "string" ? input.cwd : undefined,
+            }, undefined, roles);
+        case "PostToolUse":
+            return enforcePostToolUse(ir, {
+                tool_name: String(input.tool_name ?? ""),
+                tool_input: (input.tool_input ?? {}),
+                tool_output: typeof input.tool_output === "string" ? input.tool_output : undefined,
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+            });
+        case "UserPromptSubmit":
+            return enforceUserPromptSubmit(ir, {
+                prompt: typeof input.prompt === "string" ? input.prompt : undefined,
+            });
+        case "SubagentStop":
+            return enforceSubagentStop(ir, {
+                agent_name: typeof input.agent_name === "string" ? input.agent_name : undefined,
+                agent_type: typeof input.agent_type === "string" ? input.agent_type : undefined,
+            });
+        case "PreCompact":
+            return enforcePreCompact(ir);
+        case "Notification":
+            return enforceNotification(ir, {
+                title: typeof input.title === "string" ? input.title : undefined,
+                message: typeof input.message === "string" ? input.message : undefined,
+            });
+        case "SessionStart":
+            return enforceSessionStart(ir, {
+                cwd: typeof input.cwd === "string" ? input.cwd : undefined,
+                session_id: typeof input.session_id === "string" ? input.session_id : undefined,
+            });
+        default:
+            return { continue: true, suppressOutput: true };
+    }
+}
+// ── Tool Registration ───────────────────────────────────────
+export function createEnforceTools(projectDir) {
+    const cache = new IRCache(projectDir);
+    return [
+        {
+            name: "dna_enforce",
+            description: "Run DNA enforcement for a hook event. Uses in-memory cached IR for zero cold-start. " +
+                "Returns the same result as the dna-hook binary but without spawning a new process.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    event: {
+                        type: "string",
+                        description: "Hook event type",
+                        enum: [...VALID_EVENTS],
+                    },
+                    input: {
+                        type: "object",
+                        description: "Hook input (same fields as Claude Code passes to hooks via stdin)",
+                    },
+                },
+                required: ["event", "input"],
+            },
+            handler: async (args) => {
+                const event = String(args.event);
+                if (!VALID_EVENTS.has(event)) {
+                    return errorResult(`Invalid event: ${event}. Valid: ${[...VALID_EVENTS].join(", ")}`);
+                }
+                const cached = await cache.get();
+                if (!cached) {
+                    return errorResult("No compiled IR found. Run `dna sync` to compile your DNA config.");
+                }
+                const input = (args.input ?? {});
+                const result = dispatchEnforce(event, cached.ir, input, cached.roles);
+                // Format as human-readable text
+                const lines = [];
+                lines.push(`Decision: ${result.continue ? "allow" : "BLOCK"}`);
+                if (result.reason)
+                    lines.push(`Reason: ${result.reason}`);
+                if (result.hookSpecificOutput?.additionalContext) {
+                    lines.push(`Context: ${result.hookSpecificOutput.additionalContext}`);
+                }
+                return textResult(lines.join("\n"));
+            },
+        },
+        {
+            name: "dna_enforce_cache_status",
+            description: "Check IR cache status — whether IR is loaded, file path, and last load time",
+            inputSchema: { type: "object", properties: {} },
+            handler: async () => {
+                const cached = await cache.get();
+                if (!cached) {
+                    return textResult("IR cache: empty (no compiled IR found at .dna/compiled/ir.json)");
+                }
+                const lines = [
+                    "IR cache: loaded",
+                    `  Templates: ${cached.ir.source_dna_ids.join(", ")}`,
+                    `  Compiled: ${cached.ir.compiled_at}`,
+                    `  Directives: ${cached.ir.prompt_directives.length}`,
+                    `  Gates: ${cached.ir.pre_execution_gates.length}`,
+                    `  Filters: ${cached.ir.tool_filters.length}`,
+                ];
+                if (cached.roles) {
+                    lines.push(`  Roles: ${Object.keys(cached.roles).join(", ")}`);
+                }
+                return textResult(lines.join("\n"));
+            },
+        },
+    ];
+}

package/dist/mcp/tools-state.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Intent DNA — MCP State Management Tools (G2)
+ *
+ * Tools for reading/writing DNA governance state via MCP:
+ *   - dna_status: Overview of DNA state
+ *   - dna_workflow_read: Read current workflow state
+ *   - dna_workflow_write: Update workflow state
+ *   - dna_trace_query: Query trace data with filters
+ */
+import type { ToolDef } from "./server.js";
+export declare function createStateTools(projectDir: string): ToolDef[];

package/dist/mcp/tools-state.js

@@ -0,0 +1,160 @@
+/**
+ * Intent DNA — MCP State Management Tools (G2)
+ *
+ * Tools for reading/writing DNA governance state via MCP:
+ *   - dna_status: Overview of DNA state
+ *   - dna_workflow_read: Read current workflow state
+ *   - dna_workflow_write: Update workflow state
+ *   - dna_trace_query: Query trace data with filters
+ */
+import { resolve } from "node:path";
+import { readWorkflowState, writeWorkflowState, readTraces, listSessions } from "../hooks/state.js";
+import { loadCompiledIR } from "../runtime/plugin-adapter.js";
+import { textResult } from "./server.js";
+export function createStateTools(projectDir) {
+    return [
+        // ── dna_status ────────────────────────────────────────
+        {
+            name: "dna_status",
+            description: "Overview of DNA governance state: compiled IR info, active workflow, session list, and recent enforcement stats",
+            inputSchema: { type: "object", properties: {} },
+            handler: async () => {
+                const lines = [];
+                // IR info
+                const irPath = resolve(projectDir, ".dna", "compiled", "ir.json");
+                const compiled = await loadCompiledIR(irPath);
+                if (compiled) {
+                    lines.push(`IR: v${compiled.ir_version}, compiled ${compiled.compiled_at}`);
+                    lines.push(`  Templates: ${compiled.source_dna_ids.join(", ")}`);
+                    const ir = compiled.ir;
+                    lines.push(`  Directives: ${ir.prompt_directives.length}, Gates: ${ir.pre_execution_gates.length}, Filters: ${ir.tool_filters.length}`);
+                    if (ir.roles_scope_map?.length) {
+                        lines.push(`  Roles: ${ir.roles_scope_map.map(r => r.role_name).join(", ")}`);
+                    }
+                    if (ir.workflows_ir?.length) {
+                        lines.push(`  Workflows: ${ir.workflows_ir.map(w => w.workflow_name).join(", ")}`);
+                    }
+                }
+                else {
+                    lines.push("IR: not found (run `dna sync` to compile)");
+                }
+                // Active workflow
+                const wf = await readWorkflowState(projectDir);
+                if (wf) {
+                    lines.push(`\nWorkflow: ${wf.workflow} (active)`);
+                    lines.push(`  Step: ${wf.current_step}, Role: ${wf.current_role}, Iteration: ${wf.iteration}`);
+                    lines.push(`  Started: ${wf.started_at}`);
+                }
+                else {
+                    lines.push("\nWorkflow: none active");
+                }
+                // Sessions
+                const sessions = await listSessions(projectDir);
+                if (sessions.length > 0) {
+                    const preview = sessions.slice(0, 5).join(", ");
+                    lines.push(`\nSessions: ${sessions.length} (${preview}${sessions.length > 5 ? "..." : ""})`);
+                }
+                // Recent trace stats
+                const traces = await readTraces(projectDir, 1);
+                if (traces.length > 0) {
+                    const blocks = traces.filter(t => t.decision === "block").length;
+                    const warns = traces.filter(t => t.decision === "warn").length;
+                    lines.push(`\nTrace (24h): ${traces.length} events, ${blocks} blocks, ${warns} warns`);
+                }
+                return textResult(lines.join("\n"));
+            },
+        },
+        // ── dna_workflow_read ─────────────────────────────────
+        {
+            name: "dna_workflow_read",
+            description: "Read current workflow state (step, role, iteration, artifacts)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    session_id: { type: "string", description: "Session ID (reads root state if omitted)" },
+                },
+            },
+            handler: async (args) => {
+                const sessionId = typeof args.session_id === "string" ? args.session_id : undefined;
+                const wf = await readWorkflowState(projectDir, sessionId, 0);
+                if (!wf)
+                    return textResult("No active workflow state found.");
+                return textResult(JSON.stringify(wf, null, 2));
+            },
+        },
+        // ── dna_workflow_write ────────────────────────────────
+        {
+            name: "dna_workflow_write",
+            description: "Update workflow state (set current step, role, iteration, or deactivate)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    workflow: { type: "string", description: "Workflow name" },
+                    current_step: { type: "string", description: "Current step ID" },
+                    current_role: { type: "string", description: "Current role name" },
+                    iteration: { type: "number", description: "Current iteration number" },
+                    active: { type: "boolean", description: "Whether workflow is active (false to deactivate)" },
+                    session_id: { type: "string", description: "Session ID for isolation" },
+                },
+                required: ["workflow", "current_step", "current_role"],
+            },
+            handler: async (args) => {
+                const sessionId = typeof args.session_id === "string" ? args.session_id : undefined;
+                const existing = await readWorkflowState(projectDir, sessionId, 0);
+                const state = {
+                    active: typeof args.active === "boolean" ? args.active : true,
+                    workflow: String(args.workflow),
+                    current_step: String(args.current_step),
+                    current_role: String(args.current_role),
+                    iteration: typeof args.iteration === "number" ? args.iteration : (existing?.iteration ?? 1),
+                    session_id: sessionId ?? existing?.session_id ?? "",
+                    started_at: existing?.started_at ?? new Date().toISOString(),
+                    completed_artifacts: existing?.completed_artifacts,
+                };
+                await writeWorkflowState(projectDir, state, sessionId);
+                return textResult(`Workflow state updated: ${state.workflow} step=${state.current_step} role=${state.current_role} iteration=${state.iteration}`);
+            },
+        },
+        // ── dna_trace_query ──────────────────────────────────
+        {
+            name: "dna_trace_query",
+            description: "Query enforcement trace data with filters (blocks, warns, by tool, by path)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    days: { type: "number", description: "Days to look back (default 1)" },
+                    session_id: { type: "string", description: "Filter by session ID" },
+                    decision: { type: "string", enum: ["block", "warn", "allow"], description: "Filter by decision type" },
+                    tool_name: { type: "string", description: "Filter by tool name" },
+                    limit: { type: "number", description: "Max entries to return (default 50)" },
+                },
+            },
+            handler: async (args) => {
+                const days = typeof args.days === "number" ? args.days : 1;
+                const sessionId = typeof args.session_id === "string" ? args.session_id : undefined;
+                const decision = typeof args.decision === "string" ? args.decision : undefined;
+                const toolName = typeof args.tool_name === "string" ? args.tool_name : undefined;
+                const limit = typeof args.limit === "number" ? args.limit : 50;
+                let traces = await readTraces(projectDir, days, sessionId);
+                if (decision)
+                    traces = traces.filter(t => t.decision === decision);
+                if (toolName)
+                    traces = traces.filter(t => t.tool_name === toolName);
+                const total = traces.length;
+                traces = traces.slice(-limit);
+                const lines = [`Trace: ${total} matching entries (showing last ${traces.length})`];
+                for (const t of traces) {
+                    const parts = [t.timestamp.slice(11, 19), t.event, t.decision];
+                    if (t.tool_name)
+                        parts.push(t.tool_name);
+                    if (t.target_path)
+                        parts.push(t.target_path);
+                    if (t.reason)
+                        parts.push(`"${t.reason.slice(0, 80)}"`);
+                    lines.push("  " + parts.join(" | "));
+                }
+                return textResult(lines.join("\n"));
+            },
+        },
+    ];
+}

package/dist/mcp/transport.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Intent DNA — MCP Transport (stdio)
+ *
+ * Minimal JSON-RPC 2.0 over stdio transport for MCP protocol.
+ * Zero external dependencies — implements the protocol directly.
+ *
+ * Messages are newline-delimited JSON (one JSON object per line).
+ */
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id?: number | string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/** Send a JSON-RPC response to stdout. */
+export declare function sendResponse(response: JsonRpcResponse): void;
+/** Send a JSON-RPC success response. */
+export declare function sendResult(id: number | string | null, result: unknown): void;
+/** Send a JSON-RPC error response. */
+export declare function sendError(id: number | string | null, code: number, message: string): void;
+/**
+ * Start reading JSON-RPC messages from stdin.
+ * Calls handler for each valid message.
+ * Exits cleanly when stdin closes.
+ */
+export declare function startTransport(handler: (msg: JsonRpcRequest) => Promise<void>): void;