intentdna 1.5.2 → 1.5.3

package/dist/mcp/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+/**
+ * Intent DNA — MCP Server (`dna-mcp`)
+ *
+ * Claude Code MCP server providing DNA governance tools:
+ *   G2: State management (workflow, trace, status)
+ *   G3: Compile toolchain (compile, validate, sync)
+ *
+ * Usage: dna-mcp [--project-dir <path>]
+ *
+ * Speaks JSON-RPC 2.0 over stdio (MCP protocol).
+ */
+import { createMCPServer } from "./server.js";
+import { createStateTools } from "./tools-state.js";
+import { createCompileTools } from "./tools-compile.js";
+// Parse args
+const args = process.argv.slice(2);
+let projectDir = process.cwd();
+const dirIdx = args.indexOf("--project-dir");
+if (dirIdx !== -1 && args[dirIdx + 1]) {
+    projectDir = args[dirIdx + 1];
+}
+// Resolve version from package.json (best-effort)
+let version = "1.5.3";
+try {
+    const { readFileSync } = await import("node:fs");
+    const { resolve } = await import("node:path");
+    const { fileURLToPath } = await import("node:url");
+    const pkgPath = resolve(fileURLToPath(import.meta.url), "..", "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    version = pkg.version ?? version;
+}
+catch { /* use default */ }
+const tools = [
+    ...createStateTools(projectDir),
+    ...createCompileTools(projectDir),
+];
+createMCPServer({ name: "intentdna", version }, tools);

package/dist/mcp/server.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Intent DNA — MCP Server Framework
+ *
+ * Minimal MCP server supporting:
+ *   - initialize / initialized handshake
+ *   - tools/list — list available tools
+ *   - tools/call — execute a tool
+ *   - ping — health check
+ *
+ * Zero external dependencies. Speaks MCP protocol over stdio.
+ */
+export interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+    handler: (args: Record<string, unknown>) => Promise<ToolResult>;
+}
+export interface ToolResult {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export declare function textResult(text: string): ToolResult;
+export declare function errorResult(text: string): ToolResult;
+export interface ServerInfo {
+    name: string;
+    version: string;
+}
+/**
+ * Create and start an MCP server with the given tools.
+ * Blocks on stdin — call this as the last thing in your entry point.
+ */
+export declare function createMCPServer(info: ServerInfo, tools: ToolDef[]): void;

package/dist/mcp/server.js

@@ -0,0 +1,84 @@
+/**
+ * Intent DNA — MCP Server Framework
+ *
+ * Minimal MCP server supporting:
+ *   - initialize / initialized handshake
+ *   - tools/list — list available tools
+ *   - tools/call — execute a tool
+ *   - ping — health check
+ *
+ * Zero external dependencies. Speaks MCP protocol over stdio.
+ */
+import { startTransport, sendResult, sendError } from "./transport.js";
+// ── Result Helpers ───────────────────────────────────────
+export function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+export function errorResult(text) {
+    return { content: [{ type: "text", text }], isError: true };
+}
+/**
+ * Create and start an MCP server with the given tools.
+ * Blocks on stdin — call this as the last thing in your entry point.
+ */
+export function createMCPServer(info, tools) {
+    const toolMap = new Map();
+    for (const tool of tools) {
+        toolMap.set(tool.name, tool);
+    }
+    startTransport(async (msg) => {
+        switch (msg.method) {
+            case "initialize":
+                sendResult(msg.id ?? null, {
+                    protocolVersion: "2024-11-05",
+                    capabilities: { tools: {} },
+                    serverInfo: { name: info.name, version: info.version },
+                });
+                break;
+            case "notifications/initialized":
+                // Client acknowledgement — no response needed
+                break;
+            case "ping":
+                sendResult(msg.id ?? null, {});
+                break;
+            case "tools/list":
+                sendResult(msg.id ?? null, {
+                    tools: tools.map(t => ({
+                        name: t.name,
+                        description: t.description,
+                        inputSchema: t.inputSchema,
+                    })),
+                });
+                break;
+            case "tools/call": {
+                const params = msg.params ?? {};
+                const toolName = params.name;
+                const args = (params.arguments ?? {});
+                const tool = toolMap.get(toolName);
+                if (!tool) {
+                    sendResult(msg.id ?? null, {
+                        content: [{ type: "text", text: `Unknown tool: ${toolName}` }],
+                        isError: true,
+                    });
+                    break;
+                }
+                try {
+                    const result = await tool.handler(args);
+                    sendResult(msg.id ?? null, result);
+                }
+                catch (err) {
+                    sendResult(msg.id ?? null, {
+                        content: [{ type: "text", text: `Error: ${err instanceof Error ? err.message : String(err)}` }],
+                        isError: true,
+                    });
+                }
+                break;
+            }
+            default:
+                if (msg.id !== undefined) {
+                    sendError(msg.id, -32601, `Method not found: ${msg.method}`);
+                }
+                break;
+        }
+    });
+}

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

@@ -0,0 +1,10 @@
+/**
+ * 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 type { ToolDef } from "./server.js";
+export declare function createCompileTools(projectDir: string): ToolDef[];

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-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;

package/dist/mcp/transport.js

@@ -0,0 +1,48 @@
+/**
+ * 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).
+ */
+import { createInterface } from "node:readline";
+// ── Response Helpers ─────────────────────────────────────
+/** Send a JSON-RPC response to stdout. */
+export function sendResponse(response) {
+    process.stdout.write(JSON.stringify(response) + "\n");
+}
+/** Send a JSON-RPC success response. */
+export function sendResult(id, result) {
+    sendResponse({ jsonrpc: "2.0", id, result });
+}
+/** Send a JSON-RPC error response. */
+export function sendError(id, code, message) {
+    sendResponse({ jsonrpc: "2.0", id, error: { code, message } });
+}
+// ── Transport ────────────────────────────────────────────
+/**
+ * Start reading JSON-RPC messages from stdin.
+ * Calls handler for each valid message.
+ * Exits cleanly when stdin closes.
+ */
+export function startTransport(handler) {
+    const rl = createInterface({ input: process.stdin });
+    rl.on("line", async (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        try {
+            const msg = JSON.parse(trimmed);
+            if (msg.jsonrpc !== "2.0")
+                return;
+            await handler(msg);
+        }
+        catch {
+            // Skip malformed messages — fail-open
+        }
+    });
+    rl.on("close", () => {
+        process.exit(0);
+    });
+}