open-multi-agent-kit 0.80.2 → 0.80.4

package/dist/mcp/omk-project-server.js

@@ -1,1632 +0,0 @@
-#!/usr/bin/env node
-import { createInterface } from "readline";
-import { writeSync } from "fs";
-import { readFile, writeFile, readdir, access, realpath, stat } from "fs/promises";
-import { join, resolve, relative } from "path";
-import { execFileSync } from "child_process";
-import { MemoryStore } from "../memory/memory-store.js";
-import { canCallMcpTool, canWriteConfig, configWriteDeniedMessage, filterAllowedMcpTools, mcpToolDeniedMessage, } from "./config-permissions.js";
-import { runQualityGate } from "./quality-gate.js";
-import { saveCheckpoint, listCheckpoints, restoreCheckpoint } from "../util/checkpoint.js";
-import { getOmkVersionSync } from "../util/version.js";
-import { saveSnippet, getSnippet, deleteSnippet, searchSnippets } from "../util/snippet.js";
-import { normalizeGoal } from "../goal/intake.js";
-import { createGoalPersister } from "../goal/persistence.js";
-import { checkGoalEvidence, checkGoalConstraints } from "../goal/evidence.js";
-import { scoreGoal } from "../goal/scoring.js";
-import { suggestNextAction, evaluateMissingCriteria } from "../goal/eval-criteria.js";
-import { createStatePersister, redactSecrets } from "../orchestration/state-persister.js";
-import { loadTodos, readTodos, deriveTodosFromState, writeTodos, normalizeTodoItems, normalizeTodoWriteInput, applyTodoWriteOperations } from "../util/todo-sync.js";
-import { listActiveSessions, readSessionMeta } from "../util/session.js";
-import { readEvents, tailEvents } from "../util/events-logger.js";
-let clientDisconnected = false;
-// ─── Constants ──────────────────────────────────────────────────────────
-const PROJECT_ROOT = process.env.OMK_PROJECT_ROOT || process.cwd();
-const OMK_DIR = join(PROJECT_ROOT, ".omk");
-const OMK_MEMORY_DIR = join(OMK_DIR, "memory");
-const OMK_AGENTS_DIR = join(OMK_DIR, "agents", "roles");
-const OMK_RUNS_DIR = join(OMK_DIR, "runs");
-const OMK_CONFIG_PATH = join(OMK_DIR, "config.toml");
-const OMK_GOALS_DIR = join(OMK_DIR, "goals");
-const PROTOCOL_VERSION = "2024-11-05";
-const SERVER_NAME = "omk-project";
-const SERVER_VERSION = getOmkVersionSync();
-const MEMORY_STORE = new MemoryStore(OMK_MEMORY_DIR, {
-    projectRoot: PROJECT_ROOT,
-    source: "omk-project-mcp",
-});
-const GOAL_PERSISTER = createGoalPersister(OMK_GOALS_DIR);
-const STATE_PERSISTER = createStatePersister(OMK_RUNS_DIR);
-// ─── JSON-RPC / MCP error helpers ───────────────────────────────────────
-const JSON_RPC_METHOD_NOT_FOUND = -32601;
-const JSON_RPC_INVALID_PARAMS = -32602;
-const JSON_RPC_OMK_SERVER_ERROR = -32000;
-function errorMessage(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-function errorName(err) {
-    return err instanceof Error ? err.name : typeof err;
-}
-function writeDiagnostic(message, data) {
-    if (clientDisconnected)
-        return;
-    const payload = JSON.stringify(redactSecrets({ message, ...data }));
-    try {
-        process.stderr.write(`[omk-project-mcp] ${payload}\n`);
-    }
-    catch {
-        // stderr unavailable, silently drop
-    }
-}
-function isBrokenPipeError(err) {
-    if (!(err instanceof Error))
-        return false;
-    const code = err.code;
-    return code === "EPIPE" || code === "ERR_STREAM_DESTROYED" || code === "ERR_STREAM_WRITE_AFTER_END";
-}
-function safeWriteStdout(data) {
-    if (clientDisconnected)
-        return;
-    try {
-        writeSync(process.stdout.fd ?? 1, data);
-    }
-    catch (err) {
-        if (isBrokenPipeError(err)) {
-            clientDisconnected = true;
-            return;
-        }
-        try {
-            process.stdout.write(data);
-        }
-        catch (err2) {
-            if (isBrokenPipeError(err2)) {
-                clientDisconnected = true;
-            }
-        }
-    }
-}
-function buildErrorData(req, err, context = {}) {
-    return {
-        requestId: req.id,
-        method: req.method,
-        errorName: errorName(err),
-        ...context,
-    };
-}
-function formatToolErrorText(toolName, err) {
-    return JSON.stringify({
-        ok: false,
-        source: "omk-project-mcp",
-        tool: toolName,
-        error: {
-            message: errorMessage(err),
-            name: errorName(err),
-        },
-        hint: "This is an OMK tool-level failure, not a JSON-RPC transport failure. Fix the input or inspect the referenced OMK project state, then retry the tool.",
-    }, null, 2);
-}
-function toolResultFromValue(result) {
-    return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-    };
-}
-function toolErrorResult(toolName, err) {
-    return {
-        isError: true,
-        content: [{ type: "text", text: formatToolErrorText(toolName, err) }],
-    };
-}
-// ─── Security helpers ───────────────────────────────────────────────────
-async function safePath(inputPath, baseDir) {
-    // 1. Reject null bytes
-    if (inputPath.includes("\0")) {
-        throw new Error(`Invalid path: null byte detected`);
-    }
-    // 2. Normalize backslashes to forward slashes
-    let normalized = inputPath.replace(/\\/g, "/");
-    // 3. Decode percent-encoded sequences
-    try {
-        normalized = decodeURIComponent(normalized);
-    }
-    catch {
-        throw new Error(`Invalid path: malformed percent-encoding`);
-    }
-    // Re-check null bytes after decoding
-    if (normalized.includes("\0")) {
-        throw new Error(`Invalid path: null byte detected after decoding`);
-    }
-    const full = resolve(join(baseDir, normalized));
-    // 4. Resolve symlinks with realpath
-    const realFull = await realpath(full).catch(() => full);
-    // 5. Final guard: ensure resolved path is still under baseDir
-    const rel = relative(baseDir, realFull);
-    if (rel.startsWith("..") || rel === "..") {
-        throw new Error(`Path traversal detected: ${inputPath}`);
-    }
-    return realFull;
-}
-async function pathExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function sanitizeGoalId(goalId) {
-    const sanitized = goalId.replace(/[^a-zA-Z0-9_.-]/g, "");
-    if (sanitized !== goalId || sanitized.length === 0 || sanitized.length > 128) {
-        throw new Error(`Invalid goalId: ${goalId}`);
-    }
-    return sanitized;
-}
-function sanitizeRunId(runId) {
-    const sanitized = runId.replace(/[^a-zA-Z0-9_.-]/g, "");
-    if (sanitized !== runId || sanitized.length === 0 || sanitized.length > 128) {
-        throw new Error(`Invalid runId: ${runId}`);
-    }
-    return sanitized;
-}
-function validateMemoryWrite(content) {
-    if (!content || content.trim().length === 0) {
-        throw new Error("Memory write rejected: content is empty");
-    }
-    const trimmed = content.trim();
-    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
-        try {
-            JSON.parse(trimmed);
-        }
-        catch {
-            throw new Error("Memory write rejected: content looks like JSON but is not valid");
-        }
-    }
-}
-function sanitizeMemoryQuery(query) {
-    return query.replace(/[^\p{L}\p{N}\s\-_./:@#]/gu, "").slice(0, 200);
-}
-// ─── Resource handlers ──────────────────────────────────────────────────
-async function handleReadGoalResource(goalId) {
-    const goal = await GOAL_PERSISTER.load(sanitizeGoalId(goalId));
-    if (!goal)
-        throw new Error(`Goal not found: ${goalId}`);
-    return { content: JSON.stringify(redactSecrets(goal), null, 2) };
-}
-async function handleReadRunResource(runId) {
-    const state = await STATE_PERSISTER.load(runId);
-    if (!state)
-        throw new Error(`Run state not found: ${runId}`);
-    return { content: JSON.stringify(state, null, 2) };
-}
-async function handleReadOntologyResource() {
-    const ontology = await MEMORY_STORE.ontology();
-    if (!ontology) {
-        const status = await MEMORY_STORE.status();
-        return { content: JSON.stringify({ backend: status.backend, note: "Ontology is available when backend=local_graph" }, null, 2) };
-    }
-    return { content: JSON.stringify(ontology, null, 2) };
-}
-// ─── Prompt handlers ────────────────────────────────────────────────────
-function handleGetGoalIntakePrompt(args) {
-    const rawGoal = args?.rawGoal ?? "<paste the raw user goal here>";
-    return {
-        description: "Normalize a raw goal into a structured GoalSpec",
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `You are a goal-intake agent. Normalize the following raw goal into a structured GoalSpec (JSON).
-
-Raw goal:
-"""
-${rawGoal}
-"""
-
-Output a JSON object with these fields:
-- title: concise title (max 120 chars)
-- objective: one-paragraph objective
-- successCriteria: array of { id, description, requirement: "required"|"optional", weight, inferred: false }
-- constraints: array of { id, description }
-- nonGoals: array of strings
-- expectedArtifacts: array of { name, path?, gate? }
-- riskLevel: "low" | "medium" | "high"
-
-Only return valid JSON.`,
-                },
-            },
-        ],
-    };
-}
-function handleGetEvidenceReviewPrompt(args) {
-    const goalId = args?.goalId ?? "<goalId>";
-    return {
-        description: "Review evidence against success criteria for a goal",
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `You are an evidence-review agent. Review the collected evidence for goal ${goalId}.
-
-For each success criterion:
-1. State whether evidence exists and is sufficient.
-2. Identify gaps or risks.
-3. Recommend next steps (add evidence, re-run tests, or mark blocked).
-
-Use the omk_goal_show and omk_evidence_check tools to fetch current state before writing your review.`,
-                },
-            },
-        ],
-    };
-}
-function handleGetQualityGatePrompt(args) {
-    const scope = args?.scope ?? "all";
-    return {
-        description: "Run lint, typecheck, test, and build quality gates",
-        messages: [
-            {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `You are a quality-gate agent. Run the quality gates for scope: ${scope}.
-
-Steps:
-1. Call omk_quality_gate to execute lint, typecheck, test, and build.
-2. For any failure, read the saved log and propose a fix.
-3. Do not proceed with downstream tasks until required gates pass.
-4. Summarize results in a concise pass/fail table.`,
-                },
-            },
-        ],
-    };
-}
-// ─── Tool handlers (Goal) ───────────────────────────────────────────────
-async function handleGoalCreate(args) {
-    const spec = normalizeGoal({
-        rawPrompt: args.rawPrompt,
-        title: args.title,
-        objective: args.objective,
-        successCriteria: args.successCriteria?.map((c) => ({ ...c, inferred: false })),
-        constraints: args.constraints,
-        nonGoals: args.nonGoals,
-        expectedArtifacts: args.expectedArtifacts,
-        riskLevel: args.riskLevel,
-    });
-    await GOAL_PERSISTER.save(spec);
-    return { goalId: spec.goalId, spec };
-}
-async function handleGoalShow(args) {
-    const spec = await GOAL_PERSISTER.load(sanitizeGoalId(args.goalId));
-    if (!spec)
-        throw new Error(`Goal not found: ${args.goalId}`);
-    return { spec };
-}
-async function handleGoalList() {
-    const goals = await GOAL_PERSISTER.list();
-    return { goals };
-}
-async function handleGoalVerify(args) {
-    const goal = await GOAL_PERSISTER.load(sanitizeGoalId(args.goalId));
-    if (!goal)
-        throw new Error(`Goal not found: ${args.goalId}`);
-    let evidence = [];
-    if (args.runId) {
-        const runState = await STATE_PERSISTER.load(args.runId);
-        if (!runState)
-            throw new Error(`Run state not found: ${args.runId}`);
-        evidence = await checkGoalEvidence(goal, { root: PROJECT_ROOT, runState });
-        await GOAL_PERSISTER.saveEvidence(goal.goalId, evidence);
-    }
-    else {
-        evidence = await GOAL_PERSISTER.loadEvidence(goal.goalId);
-    }
-    const constraints = checkGoalConstraints(goal);
-    const score = scoreGoal(goal, evidence);
-    return { goalId: goal.goalId, evidence, score, constraints };
-}
-async function handleGoalClose(args) {
-    const goal = await GOAL_PERSISTER.load(sanitizeGoalId(args.goalId));
-    if (!goal)
-        throw new Error(`Goal not found: ${args.goalId}`);
-    goal.status = "closed";
-    goal.updatedAt = new Date().toISOString();
-    await GOAL_PERSISTER.save(goal);
-    return { success: true, goalId: goal.goalId };
-}
-// ─── Tool handlers (Evidence) ───────────────────────────────────────────
-async function handleEvidenceAdd(args) {
-    const goalId = sanitizeGoalId(args.goalId);
-    const goal = await GOAL_PERSISTER.load(goalId);
-    if (!goal)
-        throw new Error(`Goal not found: ${args.goalId}`);
-    const evidence = await GOAL_PERSISTER.loadEvidence(goalId);
-    evidence.push({
-        criterionId: args.criterionId,
-        passed: args.passed,
-        message: args.message,
-        ref: args.ref,
-        checkedAt: new Date().toISOString(),
-    });
-    await GOAL_PERSISTER.saveEvidence(goalId, evidence);
-    return { success: true, goalId, criterionId: args.criterionId };
-}
-async function handleEvidenceCheck(args) {
-    const goal = await GOAL_PERSISTER.load(sanitizeGoalId(args.goalId));
-    if (!goal)
-        throw new Error(`Goal not found: ${args.goalId}`);
-    let evidence = [];
-    if (args.runId) {
-        const runState = await STATE_PERSISTER.load(args.runId);
-        if (!runState)
-            throw new Error(`Run state not found: ${args.runId}`);
-        evidence = await checkGoalEvidence(goal, { root: PROJECT_ROOT, runState });
-    }
-    else {
-        evidence = await checkGoalEvidence(goal, {
-            root: PROJECT_ROOT,
-            runState: {
-                schemaVersion: 1,
-                runId: "none",
-                nodes: [],
-                startedAt: new Date().toISOString(),
-            },
-        });
-    }
-    await GOAL_PERSISTER.saveEvidence(goal.goalId, evidence);
-    const constraints = checkGoalConstraints(goal);
-    const score = scoreGoal(goal, evidence);
-    return { goalId: goal.goalId, evidence, score, constraints };
-}
-// ─── Tool handlers (Run) ────────────────────────────────────────────────
-async function handleRunState(args) {
-    const state = await STATE_PERSISTER.load(args.runId);
-    if (!state)
-        throw new Error(`Run state not found: ${args.runId}`);
-    return { state };
-}
-// ─── Tool handlers (Quality Gate) ───────────────────────────────────────
-async function handleQualityGate() {
-    const config = await readFile(OMK_CONFIG_PATH, "utf-8").catch(() => "");
-    return runQualityGate(PROJECT_ROOT, config);
-}
-// ─── Tool handlers (Memory) ─────────────────────────────────────────────
-async function handleMemoryRead(args) {
-    await safePath(args.path, OMK_MEMORY_DIR);
-    const content = await MEMORY_STORE.read(args.path);
-    return { content };
-}
-async function handleMemoryWrite(args) {
-    await safePath(args.path, OMK_MEMORY_DIR);
-    validateMemoryWrite(args.content);
-    await MEMORY_STORE.write(args.path, args.content);
-    return { success: true };
-}
-// ─── Tool handlers (Graph) ──────────────────────────────────────────────
-async function handleGraphQuery(args) {
-    return MEMORY_STORE.graphQuery(args.query);
-}
-// ─── Tool handlers (Memory Search / Status / Ontology / Mindmap) ─────────
-async function handleSearchMemory(args) {
-    const query = sanitizeMemoryQuery(args.query);
-    const limit = typeof args.limit === "number" ? Math.max(1, Math.min(50, Math.floor(args.limit))) : 10;
-    const searchResults = await MEMORY_STORE.search(query, limit);
-    return {
-        results: searchResults.map((r) => ({
-            type: "Memory",
-            name: r.path,
-            snippet: r.content.slice(0, 500),
-        })),
-    };
-}
-async function handleMemoryStatus() {
-    const status = await MEMORY_STORE.status();
-    let healthy = status.backend === "local_graph" && status.localGraph.configured;
-    let nodeCounts = {};
-    const lastSync = null;
-    try {
-        const mindmap = await MEMORY_STORE.mindmap("", 1);
-        if (mindmap) {
-            if (status.backend === "kuzu")
-                healthy = true;
-            nodeCounts = mindmap.nodes.reduce((acc, node) => {
-                acc[node.type] = (acc[node.type] ?? 0) + 1;
-                return acc;
-            }, {});
-            // lastSync not available from mindmap structure; set to null
-        }
-    }
-    catch {
-        // Fallback: node counts unavailable
-    }
-    return {
-        backend: status.backend,
-        healthy,
-        nodeCounts,
-        lastSync,
-    };
-}
-async function handleMemoryOntology(args) {
-    const ontology = await MEMORY_STORE.ontology();
-    return { ontology, nodeType: args.nodeType };
-}
-async function handleMemoryMindmap(args) {
-    const query = args.query ? sanitizeMemoryQuery(args.query) : undefined;
-    const limit = typeof args.depth === "number" ? Math.max(1, Math.min(250, args.depth * 20)) : 80;
-    const mindmap = await MEMORY_STORE.mindmap(query, limit);
-    return { mindmap };
-}
-// ─── Tool handlers (Goal Next Action) ────────────────────────────────────
-async function handleGoalNext(args) {
-    let goalId = args.goalId;
-    if (!goalId) {
-        const goals = await GOAL_PERSISTER.list();
-        for (const id of goals) {
-            const g = await GOAL_PERSISTER.load(id);
-            if (g && g.status !== "closed" && g.status !== "done" && g.status !== "cancelled") {
-                goalId = g.goalId;
-                break;
-            }
-        }
-    }
-    if (!goalId) {
-        throw new Error("No active goal found");
-    }
-    const goal = await GOAL_PERSISTER.load(sanitizeGoalId(goalId));
-    if (!goal)
-        throw new Error(`Goal not found: ${goalId}`);
-    const evidence = await GOAL_PERSISTER.loadEvidence(goal.goalId);
-    const missingCriteria = evaluateMissingCriteria(goal, evidence);
-    const suggestion = suggestNextAction(goal, evidence);
-    const recommendedCommands = [];
-    const recommendedSkills = [];
-    if (goal.riskLevel === "high") {
-        recommendedCommands.push("omk_quality_gate", "omk_save_checkpoint");
-        recommendedSkills.push("omk-plan-first", "omk-quality-gate");
-    }
-    else {
-        recommendedCommands.push("omk_quality_gate");
-        recommendedSkills.push("omk-quality-gate");
-    }
-    if (missingCriteria.some((c) => c.requirement === "required")) {
-        recommendedSkills.push("omk-test-debug-loop");
-    }
-    return {
-        goal: {
-            goalId: goal.goalId,
-            title: goal.title,
-            objective: goal.objective,
-            status: goal.status,
-        },
-        missingCriteria,
-        latestEvidence: evidence.slice(-10),
-        suggestedNextAction: suggestion,
-        recommendedCommands,
-        recommendedSkills,
-    };
-}
-// ─── Context compression with ontology grounding ─────────────────────────
-async function handleCompressContext(args) {
-    const limit = Math.max(1, Math.min(50, args.limit ?? 20));
-    const sources = [];
-    // 1. Pull ontology schema
-    try {
-        const ontology = await MEMORY_STORE.ontology();
-        if (ontology) {
-            sources.push({
-                type: "ontology",
-                label: `Project Ontology (${ontology.version})`,
-                content: `Classes: ${ontology.classes.join(", ")}\nRelations: ${ontology.relationTypes.join(", ")}`,
-            });
-        }
-    }
-    catch {
-        // ignore ontology failures
-    }
-    // 2. Pull mindmap centered on query
-    try {
-        const mindmap = await MEMORY_STORE.mindmap(args.query, limit);
-        if (mindmap && mindmap.nodes.length > 0) {
-            const relevant = mindmap.nodes
-                .filter((n) => n.type === "Goal" || n.type === "Task" || n.type === "Decision" || n.type === "Evidence" || n.type === "Concept")
-                .slice(0, limit)
-                .map((n) => `- ${n.label} (${n.type})${n.summary ? `: ${n.summary}` : ""}`)
-                .join("\n");
-            if (relevant) {
-                sources.push({
-                    type: "mindmap",
-                    label: `Mindmap: ${args.query}`,
-                    content: relevant,
-                });
-            }
-        }
-    }
-    catch {
-        // ignore mindmap failures
-    }
-    // 3. Search memory for related facts
-    try {
-        const searchResults = await MEMORY_STORE.search(args.query, limit);
-        if (searchResults.length > 0) {
-            const relevant = searchResults
-                .slice(0, Math.min(10, limit))
-                .map((r) => `- ${r.path}: ${r.content.slice(0, 200)}`)
-                .join("\n");
-            sources.push({
-                type: "search",
-                label: `Memory Search: ${args.query}`,
-                content: relevant,
-            });
-        }
-    }
-    catch {
-        // ignore search failures
-    }
-    // 4. Fetch recent ensemble decisions if query looks like a goal
-    try {
-        const { recallRecentEnsembleDecisions } = await import("../goal/ensemble-memory.js");
-        const recent = await recallRecentEnsembleDecisions(args.query, PROJECT_ROOT, 3);
-        if (recent.length > 0) {
-            const content = recent
-                .map((d) => `- [${d.timestamp}] action=${d.action}, confidence=${d.confidence.toFixed(2)}\n  ${d.candidateVotes.map((v) => `  ${v.id}: ${v.action} (weight=${v.weight}) — ${v.reason}`).join("\n")}`)
-                .join("\n");
-            sources.push({
-                type: "ensemble",
-                label: "Recent Ensemble Decisions",
-                content,
-            });
-        }
-    }
-    catch {
-        // ignore ensemble recall failures
-    }
-    // 5. Build grounded briefing
-    const briefingLines = [
-        `# Ground Truth Briefing for Context Compression`,
-        ``,
-        `> Query: ${args.query}`,
-        `> Sources: ${sources.length} (ontology, mindmap, memory search, ensemble decisions)`,
-        ``,
-        `## Rules for compression`,
-        `- Preserve every class, relation, and decision listed below.`,
-        `- Do not invent nodes, files, or APIs that are not present in the sources.`,
-        `- When summarizing, anchor statements to specific source types (ontology / mindmap / search / ensemble).`,
-        ``,
-    ];
-    for (const src of sources) {
-        briefingLines.push(`## ${src.label} [${src.type}]`, src.content, ``);
-    }
-    briefingLines.push(`## End of Ground Truth Briefing`, `Compress the conversation context above, keeping these grounded facts as immovable anchors.`);
-    return {
-        briefing: briefingLines.join("\n"),
-        sources,
-    };
-}
-// ─── Legacy tool handlers (kept for internal use, not exported) ─────────
-async function handleReadConfig() {
-    const content = await readFile(OMK_CONFIG_PATH, "utf-8").catch(() => "");
-    return { content };
-}
-async function handleWriteConfig(args) {
-    if (!canWriteConfig()) {
-        throw new Error(configWriteDeniedMessage());
-    }
-    if (!args.content || args.content.length > 100_000) {
-        throw new Error("Invalid config content: empty or exceeds 100KB");
-    }
-    await writeFile(OMK_CONFIG_PATH, args.content, "utf-8");
-    return { success: true };
-}
-async function handleListAgents() {
-    if (!(await pathExists(OMK_AGENTS_DIR)))
-        return { agents: [] };
-    const entries = await readdir(OMK_AGENTS_DIR, { withFileTypes: true });
-    const agents = entries.filter((e) => e.isFile() && e.name.endsWith(".yaml")).map((e) => e.name.replace(/\.yaml$/, ""));
-    return { agents };
-}
-async function handleReadAgent(args) {
-    const full = await safePath(`${args.name}.yaml`, OMK_AGENTS_DIR);
-    const content = await readFile(full, "utf-8").catch(() => "");
-    return { content };
-}
-async function handleListRuns() {
-    if (!(await pathExists(OMK_RUNS_DIR)))
-        return { runs: [] };
-    const entries = await readdir(OMK_RUNS_DIR, { withFileTypes: true });
-    const runs = entries
-        .filter((e) => e.isDirectory())
-        .map((e) => ({
-        id: e.name,
-        createdAt: parseRunDate(e.name),
-    }))
-        .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
-    return { runs };
-}
-function parseRunDate(runId) {
-    try {
-        const parts = runId.split("T");
-        if (parts.length === 2) {
-            const date = parts[0];
-            const time = parts[1].replace(/-/g, ":").replace(/:(\d+)Z$/, ".$1Z");
-            return `${date}T${time}`;
-        }
-        return runId;
-    }
-    catch {
-        return runId;
-    }
-}
-async function handleReadRun(args) {
-    const runDir = await safePath(args.runId, OMK_RUNS_DIR);
-    const [goal, plan] = await Promise.all([
-        readFile(join(runDir, "goal.md"), "utf-8").catch(() => ""),
-        readFile(join(runDir, "plan.md"), "utf-8").catch(() => ""),
-    ]);
-    return { goal, plan };
-}
-async function handleGetProjectInfo() {
-    const config = await readFile(OMK_CONFIG_PATH, "utf-8").catch(() => "");
-    const nameMatch = config.match(/^name\s*=\s*"([^"]+)"/m);
-    const descMatch = config.match(/^description\s*=\s*"([^"]*)"/m);
-    let gitBranch;
-    let gitClean = true;
-    let gitChanges = 0;
-    try {
-        gitBranch = execFileSync("git", ["branch", "--show-current"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 3000 }).trim();
-        const status = execFileSync("git", ["status", "--porcelain"], { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 3000 }).trim();
-        const lines = status.split("\n").filter((l) => l.trim().length > 0);
-        gitChanges = lines.length;
-        gitClean = lines.length === 0;
-    }
-    catch {
-        // ignore git errors
-    }
-    return {
-        name: nameMatch?.[1] ?? "my-project",
-        description: descMatch?.[1] ?? undefined,
-        gitBranch,
-        gitClean,
-        gitChanges,
-    };
-}
-async function handleGetQualitySettings() {
-    const config = await readFile(OMK_CONFIG_PATH, "utf-8").catch(() => "");
-    const lint = config.match(/^lint\s*=\s*"([^"]+)"/m)?.[1] ?? "auto";
-    const test = config.match(/^test\s*=\s*"([^"]+)"/m)?.[1] ?? "auto";
-    const typecheck = config.match(/^typecheck\s*=\s*"([^"]+)"/m)?.[1] ?? "auto";
-    const build = config.match(/^build\s*=\s*"([^"]+)"/m)?.[1] ?? "auto";
-    return { lint, test, typecheck, build };
-}
-async function handleGetApprovalPolicy() {
-    const config = await readFile(OMK_CONFIG_PATH, "utf-8").catch(() => "");
-    const policy = config.match(/^approval_policy\s*=\s*"([^"]+)"/m)?.[1] ?? "auto";
-    return { policy };
-}
-async function handleListWorktrees() {
-    const worktreesDir = join(OMK_DIR, "worktrees");
-    if (!(await pathExists(worktreesDir)))
-        return { worktrees: [] };
-    const result = [];
-    const runEntries = await readdir(worktreesDir, { withFileTypes: true });
-    for (const runEntry of runEntries) {
-        if (!runEntry.isDirectory())
-            continue;
-        const runPath = join(worktreesDir, runEntry.name);
-        const nodeEntries = await readdir(runPath, { withFileTypes: true });
-        for (const nodeEntry of nodeEntries) {
-            if (nodeEntry.isDirectory()) {
-                result.push(join(runPath, nodeEntry.name));
-            }
-        }
-    }
-    return { worktrees: result };
-}
-async function handleRunQualityGatePrint() {
-    const config = await readFile(OMK_CONFIG_PATH, "utf-8").catch(() => "");
-    const results = await runQualityGate(PROJECT_ROOT, config);
-    const { printQualityGateResults } = await import("./quality-gate.js");
-    return { text: printQualityGateResults(results, true) };
-}
-async function handleSaveCheckpoint(args) {
-    return saveCheckpoint(args.runId, args.label, args.metadata);
-}
-async function handleListCheckpoints(args) {
-    const checkpoints = await listCheckpoints(args.runId);
-    return { checkpoints };
-}
-async function handleRestoreCheckpoint(args) {
-    return restoreCheckpoint(args.checkpointId, args.runId, { force: args.force === true });
-}
-// ─── Tool handlers (Session / TODO) ─────────────────────────────────────
-async function handleListSessions(args) {
-    const status = args.status;
-    if (!status || status === "active") {
-        const sessions = await listActiveSessions();
-        return { sessions };
-    }
-    const runsDir = join(OMK_DIR, "runs");
-    if (!(await pathExists(runsDir)))
-        return { sessions: [] };
-    const entries = await readdir(runsDir, { withFileTypes: true });
-    const sessions = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const meta = await readSessionMeta(entry.name).catch(() => null);
-        if (meta && meta.status === status) {
-            sessions.push(meta);
-        }
-    }
-    return { sessions: sessions.sort((a, b) => b.startedAt.localeCompare(a.startedAt)) };
-}
-async function handleReadTodos(args) {
-    const fromFile = await readTodos(args.runId);
-    if (fromFile !== null) {
-        return { todos: redactSecrets(fromFile), source: "todos.json" };
-    }
-    const fromState = await deriveTodosFromState(args.runId);
-    if (fromState && fromState.length > 0) {
-        return { todos: redactSecrets(fromState), source: "state.json" };
-    }
-    return { todos: [], source: null };
-}
-async function handleTailRunEvents(args) {
-    const runId = sanitizeRunId(args.runId);
-    const runDir = join(OMK_RUNS_DIR, runId);
-    const events = await tailEvents(runDir, {
-        afterSeq: typeof args.afterSeq === "number" ? args.afterSeq : undefined,
-        limit: typeof args.limit === "number" ? Math.max(0, Math.min(500, args.limit)) : 200,
-    });
-    return { events: redactSecrets(events), source: "events.ndjson" };
-}
-async function handleReadRunState(args) {
-    const runId = sanitizeRunId(args.runId);
-    const [state, events, todos] = await Promise.all([
-        STATE_PERSISTER.load(runId),
-        readEvents(join(OMK_RUNS_DIR, runId)).catch(() => []),
-        loadTodos(runId).catch(() => null),
-    ]);
-    return { state: redactSecrets(state), events: redactSecrets(events), todos: redactSecrets(todos) };
-}
-async function handleReadRuntimeStatus(args = {}) {
-    const runId = args.runId ? sanitizeRunId(args.runId) : await resolveLatestRunIdForMcp();
-    if (!runId)
-        return { runId: null, state: null, events: [], todos: null, mcpStatus: null };
-    const mcpStatusPath = join(OMK_RUNS_DIR, runId, "mcp-status.json");
-    const [state, events, todos, mcpStatus] = await Promise.all([
-        STATE_PERSISTER.load(runId),
-        tailEvents(join(OMK_RUNS_DIR, runId), { limit: 200 }).catch(() => []),
-        loadTodos(runId).catch(() => null),
-        readFile(mcpStatusPath, "utf-8").then((raw) => redactSecrets(JSON.parse(raw))).catch(() => null),
-    ]);
-    return { runId, state: redactSecrets(state), events: redactSecrets(events), todos: redactSecrets(todos), mcpStatus };
-}
-async function resolveLatestRunIdForMcp() {
-    if (!(await pathExists(OMK_RUNS_DIR)))
-        return null;
-    const entries = await readdir(OMK_RUNS_DIR, { withFileTypes: true });
-    let best = null;
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const statePath = join(OMK_RUNS_DIR, entry.name, "state.json");
-        try {
-            const real = await safePath(join(entry.name, "state.json"), OMK_RUNS_DIR);
-            if (real !== statePath && !real.endsWith(join(entry.name, "state.json")))
-                continue;
-            const stats = await stat(statePath);
-            if (!best || stats.mtimeMs > best.mtimeMs)
-                best = { name: entry.name, mtimeMs: stats.mtimeMs };
-        }
-        catch {
-            // ignore invalid run directories
-        }
-    }
-    return best?.name ?? null;
-}
-async function resolveTodoWriteRunId(runId) {
-    const candidate = runId ?? process.env.OMK_SESSION_ID ?? await resolveLatestRunIdForMcp();
-    if (!candidate) {
-        throw new Error("TodoWrite requires runId when no active OMK session can be inferred");
-    }
-    return sanitizeRunId(candidate);
-}
-async function handleWriteTodos(args) {
-    const runId = sanitizeRunId(args.runId);
-    const todos = normalizeTodoItems(args.todos);
-    await writeTodos(runId, todos);
-    return { runId, written: todos.length };
-}
-async function handleTodoWrite(args) {
-    const input = args && typeof args === "object" ? args : {};
-    const runId = await resolveTodoWriteRunId(input.runId);
-    const todos = normalizeTodoWriteInput(args);
-    await writeTodos(runId, todos);
-    return { runId, written: todos.length, source: "TodoWrite" };
-}
-async function handleOmkTodoWrite(args) {
-    const runId = await resolveTodoWriteRunId(args.runId);
-    const existing = await readTodos(runId).then((todos) => todos ?? []);
-    const result = applyTodoWriteOperations(existing, args.ops);
-    await writeTodos(runId, result.todos);
-    return {
-        runId,
-        applied: result.applied,
-        written: result.todos.length,
-        todos: redactSecrets(result.todos),
-    };
-}
-// ─── Resource registry ──────────────────────────────────────────────────
-const RESOURCES = [
-    {
-        uri: "omk://goal/{goalId}",
-        name: "GoalSpec",
-        description: "Structured goal specification JSON by goal ID",
-        mimeType: "application/json",
-    },
-    {
-        uri: "omk://run/{runId}",
-        name: "RunState",
-        description: "Run state JSON by run ID",
-        mimeType: "application/json",
-    },
-    {
-        uri: "omk://ontology/project",
-        name: "ProjectOntology",
-        description: "Project ontology graph summary from the memory backend",
-        mimeType: "application/json",
-    },
-];
-// ─── Prompt registry ────────────────────────────────────────────────────
-const PROMPTS = [
-    {
-        name: "goal-intake",
-        description: "Prompt template for normalizing a raw goal into GoalSpec",
-        arguments: [{ name: "rawGoal", description: "The raw user goal text", required: false }],
-    },
-    {
-        name: "evidence-review",
-        description: "Prompt template for reviewing evidence against criteria",
-        arguments: [{ name: "goalId", description: "Goal ID to review", required: false }],
-    },
-    {
-        name: "quality-gate",
-        description: "Prompt template for running lint/test/build/audit",
-        arguments: [{ name: "scope", description: "Scope of gates to run (default: all)", required: false }],
-    },
-];
-// ─── Tool registry ──────────────────────────────────────────────────────
-const TOOLS = [
-    // ── Goal lifecycle ──
-    {
-        name: "omk_goal_create",
-        description: "Create a GoalSpec from a raw prompt. Infers title, objective, criteria, and risk level.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                rawPrompt: { type: "string", description: "Raw user goal text" },
-                title: { type: "string", description: "Optional explicit title" },
-                objective: { type: "string", description: "Optional explicit objective" },
-                successCriteria: {
-                    type: "array",
-                    description: "Optional explicit success criteria",
-                    items: {
-                        type: "object",
-                        properties: {
-                            id: { type: "string" },
-                            description: { type: "string" },
-                            requirement: { type: "string", enum: ["required", "optional"] },
-                            weight: { type: "number" },
-                        },
-                        required: ["id", "description", "requirement", "weight"],
-                    },
-                },
-                constraints: { type: "array", description: "Optional constraint descriptions", items: { type: "string" } },
-                nonGoals: { type: "array", description: "Explicit out-of-scope items", items: { type: "string" } },
-                expectedArtifacts: {
-                    type: "array",
-                    description: "Expected deliverables",
-                    items: {
-                        type: "object",
-                        properties: {
-                            name: { type: "string" },
-                            path: { type: "string" },
-                        },
-                        required: ["name"],
-                    },
-                },
-                riskLevel: { type: "string", enum: ["low", "medium", "high"], description: "Optional risk override" },
-            },
-            required: ["rawPrompt"],
-        },
-    },
-    {
-        name: "omk_goal_show",
-        description: "Read a GoalSpec by ID",
-        inputSchema: {
-            type: "object",
-            properties: {
-                goalId: { type: "string", description: "Goal identifier" },
-            },
-            required: ["goalId"],
-        },
-    },
-    {
-        name: "omk_goal_list",
-        description: "List all goal IDs",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "omk_goal_verify",
-        description: "Verify goal evidence and compute a pass/fail score",
-        inputSchema: {
-            type: "object",
-            properties: {
-                goalId: { type: "string", description: "Goal identifier" },
-                runId: { type: "string", description: "Optional run ID to pull node-level evidence from" },
-            },
-            required: ["goalId"],
-        },
-    },
-    {
-        name: "omk_goal_close",
-        description: "Close a goal by ID",
-        inputSchema: {
-            type: "object",
-            properties: {
-                goalId: { type: "string", description: "Goal identifier" },
-            },
-            required: ["goalId"],
-        },
-    },
-    // ── Evidence ──
-    {
-        name: "omk_evidence_add",
-        description: "Add evidence to a success criterion",
-        inputSchema: {
-            type: "object",
-            properties: {
-                goalId: { type: "string", description: "Goal identifier" },
-                criterionId: { type: "string", description: "Criterion identifier" },
-                passed: { type: "boolean", description: "Whether the criterion is satisfied" },
-                message: { type: "string", description: "Human-readable evidence summary" },
-                ref: { type: "string", description: "Reference (URL, commit, file path)" },
-            },
-            required: ["goalId", "criterionId", "passed"],
-        },
-    },
-    {
-        name: "omk_evidence_check",
-        description: "Check evidence gates for a goal (artifact gates + criterion stubs)",
-        inputSchema: {
-            type: "object",
-            properties: {
-                goalId: { type: "string", description: "Goal identifier" },
-                runId: { type: "string", description: "Optional run ID to pull node-level evidence from" },
-            },
-            required: ["goalId"],
-        },
-    },
-    // ── Run ──
-    {
-        name: "omk_run_state",
-        description: "Get run state by ID",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Run identifier" },
-            },
-            required: ["runId"],
-        },
-    },
-    {
-        name: "omk_tail_run_events",
-        description: "Tail append-only telemetry events for a run (secret-free summaries only)",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Run identifier" },
-                afterSeq: { type: "number", description: "Only return events with seq greater than this value" },
-                limit: { type: "number", description: "Maximum events to return (0-500, default 200)" },
-            },
-            required: ["runId"],
-        },
-    },
-    {
-        name: "omk_read_run_state",
-        description: "Read run state plus telemetry and canonical todos for a run",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Run identifier" },
-            },
-            required: ["runId"],
-        },
-    },
-    {
-        name: "omk_read_runtime_status",
-        description: "Read latest or selected run state, telemetry, todos, and MCP status metadata",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Optional run identifier; latest run is used when omitted" },
-            },
-        },
-    },
-    // ── Quality gate ──
-    {
-        name: "omk_quality_gate",
-        description: "Run quality gates: lint, typecheck, test, and build",
-        inputSchema: { type: "object", properties: {} },
-    },
-    // ── Memory ──
-    {
-        name: "omk_memory_read",
-        description: "Read canonical full project memory content from the graph or filesystem mirror",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Relative path under .omk/memory/" },
-            },
-            required: ["path"],
-        },
-    },
-    {
-        name: "omk_memory_write",
-        description: "Write canonical project memory with validation (non-empty, JSON-checked)",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "Relative path under .omk/memory/" },
-                content: { type: "string", description: "Content to write" },
-            },
-            required: ["path", "content"],
-        },
-    },
-    // ── Graph ──
-    {
-        name: "omk_graph_query",
-        description: "Run read-only queries over the graph memory backend. local_graph supports GraphQL-lite (ontology, memory, memories, mindmap, nodes). kuzu supports read-only Cypher queries.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: 'GraphQL-lite example: query { mindmap(query: "decision", limit: 20) { root nodes edges } }. Cypher example: MATCH (n:OmkTask {projectId: $projectId}) RETURN n LIMIT 10',
-                },
-            },
-            required: ["query"],
-        },
-    },
-    // ── Memory search / status / ontology / mindmap ──
-    {
-        name: "omk_search_memory",
-        description: "Search the configured local graph or Kuzu memory backend for nodes matching query",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string", description: "Search query string" },
-                limit: { type: "number", description: "Max results (1-50, default 10)" },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "omk_memory_status",
-        description: "Return current memory backend status, connection health, node counts, and last sync timestamp",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "omk_memory_ontology",
-        description: "Return the ontology schema for the requested node type, or all node types if not specified",
-        inputSchema: {
-            type: "object",
-            properties: {
-                nodeType: { type: "string", description: "Optional node type to filter schema" },
-            },
-        },
-    },
-    {
-        name: "omk_memory_mindmap",
-        description: "Return a mindmap-style subgraph centered on the query term, or project-level root graph if no query",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string", description: "Optional center query term" },
-                depth: { type: "number", description: "Optional exploration depth (maps to result limit)" },
-            },
-        },
-    },
-    // ── Goal next action ──
-    {
-        name: "omk_goal_next",
-        description: "Get the next recommended action for a goal. Uses the latest active goal if goalId is omitted.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                goalId: { type: "string", description: "Optional goal identifier" },
-            },
-        },
-    },
-    // ── Context compression with ontology grounding ──
-    {
-        name: "omk_compress_context",
-        description: "Prepare a hallucination-resistant context briefing by pulling the ontology, mindmap, and recent ensemble decisions before calling ctx_compress. Returns a grounded summary that should be prepended to the ctx_compress call.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: { type: "string", description: "Topic or goal to center the briefing on" },
-                limit: { type: "number", description: "Max nodes to fetch (default 20)" },
-            },
-            required: ["query"],
-        },
-    },
-    // ── Session / TODO ──
-    {
-        name: "omk_list_sessions",
-        description: "List active or recent chat sessions with metadata",
-        inputSchema: {
-            type: "object",
-            properties: {
-                status: { type: "string", description: "Optional filter by status (active, completed, failed, idle)" },
-            },
-        },
-    },
-    {
-        name: "omk_read_todos",
-        description: "Read TODO items for a run",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Run identifier" },
-            },
-            required: ["runId"],
-        },
-    },
-    {
-        name: "omk_write_todos",
-        description: "Write or update TODO items for a run",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Run identifier" },
-                todos: {
-                    type: "array",
-                    description: "TODO items to write",
-                    items: {
-                        type: "object",
-                        properties: {
-                            title: { type: "string" },
-                            status: { type: "string" },
-                            agent: { type: "string" },
-                            role: { type: "string" },
-                            startedAt: { type: "string" },
-                            completedAt: { type: "string" },
-                            elapsedMs: { type: "number" },
-                            evidence: { type: "string" },
-                            description: { type: "string" },
-                        },
-                        required: ["title", "status"],
-                    },
-                },
-            },
-            required: ["runId", "todos"],
-        },
-    },
-    {
-        name: "omk_todo_write",
-        description: "Apply phased todo_write operations to the run TODO list. Supports init/start/done/drop/rm/append/note.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Optional run identifier; current/latest run is used when omitted" },
-                ops: {
-                    type: "array",
-                    description: "Todo operations in order",
-                    items: {
-                        type: "object",
-                        properties: {
-                            op: { type: "string", enum: ["init", "start", "done", "drop", "rm", "append", "note"] },
-                            list: {
-                                type: "array",
-                                description: "For init: phased task list",
-                                items: {
-                                    type: "object",
-                                    properties: {
-                                        phase: { type: "string" },
-                                        items: { type: "array", items: { type: "string" } },
-                                    },
-                                    required: ["phase", "items"],
-                                },
-                            },
-                            task: { type: "string", description: "Task title for task-scoped operations" },
-                            phase: { type: "string", description: "Phase name for phase-scoped operations or append" },
-                            items: { type: "array", items: { type: "string" }, description: "Tasks to append" },
-                            text: { type: "string", description: "Note text for note operation" },
-                        },
-                        required: ["op"],
-                    },
-                },
-            },
-            required: ["ops"],
-        },
-    },
-    {
-        name: "TodoWrite",
-        description: "Claude-compatible TodoWrite tool. Replaces the run TODO list from todos: [{ content, status, activeForm? }]. Status values are pending, in_progress, or completed.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Optional run identifier; current/latest run is used when omitted" },
-                todos: {
-                    type: "array",
-                    description: "Claude TodoWrite items",
-                    items: {
-                        type: "object",
-                        properties: {
-                            content: { type: "string", description: "Stable todo text" },
-                            status: { type: "string", enum: ["pending", "in_progress", "completed"] },
-                            activeForm: { type: "string", description: "Present-continuous text shown while in_progress" },
-                        },
-                        required: ["content", "status"],
-                    },
-                },
-            },
-            required: ["todos"],
-        },
-    },
-    {
-        name: "todo_write",
-        description: "Alias for omk_todo_write. Applies phased todo_write operations: init/start/done/drop/rm/append/note.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                runId: { type: "string", description: "Optional run identifier; current/latest run is used when omitted" },
-                ops: {
-                    type: "array",
-                    description: "Todo operations in order",
-                    items: {
-                        type: "object",
-                        properties: {
-                            op: { type: "string", enum: ["init", "start", "done", "drop", "rm", "append", "note"] },
-                            list: {
-                                type: "array",
-                                description: "For init: phased task list",
-                                items: {
-                                    type: "object",
-                                    properties: {
-                                        phase: { type: "string" },
-                                        items: { type: "array", items: { type: "string" } },
-                                    },
-                                    required: ["phase", "items"],
-                                },
-                            },
-                            task: { type: "string", description: "Task title for task-scoped operations" },
-                            phase: { type: "string", description: "Phase name for phase-scoped operations or append" },
-                            items: { type: "array", items: { type: "string" }, description: "Tasks to append" },
-                            text: { type: "string", description: "Note text for note operation" },
-                        },
-                        required: ["op"],
-                    },
-                },
-            },
-            required: ["ops"],
-        },
-    },
-];
-async function handleToolCall(name, args) {
-    if (!canCallMcpTool(name)) {
-        throw new Error(mcpToolDeniedMessage(name));
-    }
-    switch (name) {
-        // Goal lifecycle
-        case "omk_goal_create":
-            return handleGoalCreate(args);
-        case "omk_goal_show":
-            return handleGoalShow(args);
-        case "omk_goal_list":
-            return handleGoalList();
-        case "omk_goal_verify":
-            return handleGoalVerify(args);
-        case "omk_goal_close":
-            return handleGoalClose(args);
-        // Evidence
-        case "omk_evidence_add":
-            return handleEvidenceAdd(args);
-        case "omk_evidence_check":
-            return handleEvidenceCheck(args);
-        // Run
-        case "omk_run_state":
-            return handleRunState(args);
-        case "omk_tail_run_events":
-            return handleTailRunEvents(args);
-        case "omk_read_run_state":
-            return handleReadRunState(args);
-        case "omk_read_runtime_status":
-            return handleReadRuntimeStatus(args);
-        // Quality gate
-        case "omk_quality_gate":
-            return handleQualityGate();
-        // Memory
-        case "omk_memory_read":
-            return handleMemoryRead(args);
-        case "omk_memory_write":
-            return handleMemoryWrite(args);
-        // Graph
-        case "omk_graph_query":
-            return handleGraphQuery(args);
-        // Memory search / status / ontology / mindmap
-        case "omk_search_memory":
-            return handleSearchMemory(args);
-        case "omk_memory_status":
-            return handleMemoryStatus();
-        case "omk_memory_ontology":
-            return handleMemoryOntology(args);
-        case "omk_memory_mindmap":
-            return handleMemoryMindmap(args);
-        // Goal next action
-        case "omk_goal_next":
-            return handleGoalNext(args);
-        // Context compression with ontology grounding
-        case "omk_compress_context":
-            return handleCompressContext(args);
-        // Session / TODO
-        case "omk_list_sessions":
-            return handleListSessions(args);
-        case "omk_read_todos":
-            return handleReadTodos(args);
-        case "omk_write_todos":
-            return handleWriteTodos(args);
-        case "TodoWrite":
-            return handleTodoWrite(args);
-        case "omk_todo_write":
-        case "todo_write":
-            return handleOmkTodoWrite(args);
-        // Legacy aliases (still callable for backward compatibility)
-        case "omk_read_memory":
-            return handleMemoryRead(args);
-        case "omk_write_memory":
-            return handleMemoryWrite(args);
-        case "omk_read_config":
-            return handleReadConfig();
-        case "omk_write_config":
-            return handleWriteConfig(args);
-        case "omk_list_agents":
-            return handleListAgents();
-        case "omk_read_agent":
-            return handleReadAgent(args);
-        case "omk_list_runs":
-            return handleListRuns();
-        case "omk_read_run":
-            return handleReadRun(args);
-        case "omk_get_project_info":
-            return handleGetProjectInfo();
-        case "omk_get_quality_settings":
-            return handleGetQualitySettings();
-        case "omk_get_approval_policy":
-            return handleGetApprovalPolicy();
-        case "omk_list_worktrees":
-            return handleListWorktrees();
-        case "omk_run_quality_gate":
-            return handleQualityGate();
-        case "omk_run_quality_gate_print":
-            return handleRunQualityGatePrint();
-        case "omk_save_checkpoint":
-            return handleSaveCheckpoint(args);
-        case "omk_list_checkpoints":
-            return handleListCheckpoints(args);
-        case "omk_restore_checkpoint":
-            return handleRestoreCheckpoint(args);
-        case "omk_save_snippet":
-            return saveSnippet(args.name, args.content, args.tags);
-        case "omk_search_snippets":
-            return searchSnippets(args.query ?? "", args.limit);
-        case "omk_get_snippet":
-            return getSnippet(args.name);
-        case "omk_delete_snippet":
-            return deleteSnippet(args.name);
-        default:
-            throw new Error(`Unknown tool: ${name}`);
-    }
-}
-// ─── Server loop ────────────────────────────────────────────────────────
-function sendResponse(res) {
-    const data = JSON.stringify(res) + "\n";
-    safeWriteStdout(data);
-}
-function sendError(id, code, message, data) {
-    sendResponse({ jsonrpc: "2.0", id, error: { code, message, data } });
-}
-function sendResult(id, result) {
-    sendResponse({ jsonrpc: "2.0", id, result });
-}
-async function handleRequest(req) {
-    switch (req.method) {
-        case "initialize": {
-            sendResult(req.id, {
-                protocolVersion: PROTOCOL_VERSION,
-                capabilities: {
-                    tools: {},
-                    resources: { listChanged: false },
-                    prompts: { listChanged: false },
-                },
-                serverInfo: {
-                    name: SERVER_NAME,
-                    version: SERVER_VERSION,
-                },
-            });
-            return;
-        }
-        case "notifications/initialized":
-            // No response needed for notifications
-            return;
-        case "resources/list": {
-            sendResult(req.id, { resources: RESOURCES });
-            return;
-        }
-        case "resources/read": {
-            const resourceParams = req.params;
-            const uri = resourceParams?.uri;
-            if (!uri || typeof uri !== "string") {
-                sendError(req.id, JSON_RPC_INVALID_PARAMS, "Invalid params: missing 'uri'");
-                return;
-            }
-            try {
-                let result;
-                if (uri.startsWith("omk://goal/")) {
-                    const goalId = uri.slice("omk://goal/".length);
-                    result = await handleReadGoalResource(goalId);
-                }
-                else if (uri.startsWith("omk://run/")) {
-                    const runId = uri.slice("omk://run/".length);
-                    result = await handleReadRunResource(runId);
-                }
-                else if (uri === "omk://ontology/project") {
-                    result = await handleReadOntologyResource();
-                }
-                else {
-                    sendError(req.id, JSON_RPC_INVALID_PARAMS, `Resource not found: ${uri}`);
-                    return;
-                }
-                sendResult(req.id, {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: "application/json",
-                            text: result.content,
-                        },
-                    ],
-                });
-            }
-            catch (err) {
-                const data = buildErrorData(req, err, { uri });
-                writeDiagnostic("resource_read_failed", data);
-                sendError(req.id, JSON_RPC_OMK_SERVER_ERROR, `OMK MCP resource read failed: ${errorMessage(err)}`, data);
-            }
-            return;
-        }
-        case "prompts/list": {
-            sendResult(req.id, { prompts: PROMPTS });
-            return;
-        }
-        case "prompts/get": {
-            const promptParams = req.params;
-            const promptName = promptParams?.name;
-            const promptArgs = promptParams?.arguments ?? {};
-            if (!promptName || typeof promptName !== "string") {
-                sendError(req.id, JSON_RPC_INVALID_PARAMS, "Invalid params: missing 'name'");
-                return;
-            }
-            try {
-                let result;
-                switch (promptName) {
-                    case "goal-intake":
-                        result = handleGetGoalIntakePrompt(promptArgs);
-                        break;
-                    case "evidence-review":
-                        result = handleGetEvidenceReviewPrompt(promptArgs);
-                        break;
-                    case "quality-gate":
-                        result = handleGetQualityGatePrompt(promptArgs);
-                        break;
-                    default:
-                        sendError(req.id, JSON_RPC_INVALID_PARAMS, `Prompt not found: ${promptName}`);
-                        return;
-                }
-                sendResult(req.id, result);
-            }
-            catch (err) {
-                const data = buildErrorData(req, err, { promptName });
-                writeDiagnostic("prompt_get_failed", data);
-                sendError(req.id, JSON_RPC_OMK_SERVER_ERROR, `OMK MCP prompt get failed: ${errorMessage(err)}`, data);
-            }
-            return;
-        }
-        case "tools/list": {
-            sendResult(req.id, { tools: filterAllowedMcpTools(TOOLS) });
-            return;
-        }
-        case "tools/call": {
-            const params = req.params;
-            const toolName = params?.name;
-            const toolArgs = params?.arguments ?? {};
-            if (!toolName || typeof toolName !== "string") {
-                sendError(req.id, JSON_RPC_INVALID_PARAMS, "Invalid params: missing 'name'");
-                return;
-            }
-            try {
-                const result = await handleToolCall(toolName, toolArgs);
-                sendResult(req.id, toolResultFromValue(result));
-            }
-            catch (err) {
-                writeDiagnostic("tool_call_failed", buildErrorData(req, err, { toolName }));
-                sendResult(req.id, toolErrorResult(toolName, err));
-            }
-            return;
-        }
-        default: {
-            sendError(req.id, JSON_RPC_METHOD_NOT_FOUND, `Method not found: ${req.method}`);
-            return;
-        }
-    }
-}
-async function main() {
-    // Ensure synchronous stdout in piped environments (MCP stdio)
-    try {
-        const stdoutWithHandle = process.stdout;
-        stdoutWithHandle._handle?.setBlocking?.(true);
-    }
-    catch {
-        // ignore if unavailable
-    }
-    process.stdout.on("error", (err) => {
-        if (isBrokenPipeError(err)) {
-            clientDisconnected = true;
-        }
-    });
-    process.stderr.on("error", () => {
-        // stderr errors are non-fatal for MCP server
-    });
-    const rl = createInterface({ input: process.stdin, crlfDelay: Infinity });
-    for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let req;
-        try {
-            req = JSON.parse(trimmed);
-        }
-        catch {
-            // Not valid JSON — can't reply without an id, so ignore
-            continue;
-        }
-        if (req.jsonrpc !== "2.0")
-            continue;
-        try {
-            await handleRequest(req);
-        }
-        catch (err) {
-            const data = buildErrorData(req, err);
-            writeDiagnostic("request_failed", data);
-            sendError(req.id, JSON_RPC_OMK_SERVER_ERROR, `OMK MCP request failed while handling ${req.method}: ${errorMessage(err)}`, data);
-        }
-    }
-    clientDisconnected = true;
-    // Gracefully flush remaining stdout before the process exits
-    try {
-        process.stdout.end?.();
-    }
-    catch {
-        // ignore
-    }
-}
-main().catch((err) => {
-    if (isBrokenPipeError(err))
-        return;
-    try {
-        console.error("Fatal error:", err);
-    }
-    catch {
-        // stderr unavailable
-    }
-});