@kage-core/kage-graph-mcp 1.0.0 → 1.1.1

package/dist/index.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTools = listTools;
+exports.callTool = callTool;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const kernel_js_1 = require("./kernel.js");
 const BASE_URL = "https://raw.githubusercontent.com/kage-core/kage-graph/master";
 async function fetchText(url) {
     const res = await fetch(url);
@@ -15,12 +18,18 @@ async function fetchJSON(url) {
     const text = await fetchText(url);
     return JSON.parse(text);
 }
+function domainNodeCount(domain) {
+    return (0, kernel_js_1.catalogDomainNodeCount)(domain);
+}
+function domainTopTags(domain) {
+    return domain.top_tags ?? [];
+}
 function scoreMatch(query, node) {
-    const terms = query.toLowerCase().split(/\s+/);
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
     let score = 0;
     const title = node.title.toLowerCase();
     const summary = (node.summary || "").toLowerCase();
-    const tags = node.tags.map((t) => t.toLowerCase());
+    const tags = (node.tags ?? []).map((t) => t.toLowerCase());
     for (const term of terms) {
         if (title.includes(term))
             score += 3;
@@ -32,14 +41,22 @@ function scoreMatch(query, node) {
     return score;
 }
 function scoreDomainMatch(query, domain) {
-    const terms = query.toLowerCase().split(/\s+/);
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const tags = domainTopTags(domain);
     return terms.reduce((sum, term) => {
-        return sum + domain.top_tags.filter((t) => t.includes(term)).length;
+        return sum + tags.filter((t) => t.includes(term)).length;
     }, 0);
 }
-const server = new index_js_1.Server({ name: "kage-graph", version: "1.0.0" }, { capabilities: { tools: {} } });
-server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
-    tools: [
+function arrayArg(value) {
+    if (Array.isArray(value))
+        return value.map(String);
+    if (typeof value === "string")
+        return value.split(",").map((item) => item.trim()).filter(Boolean);
+    return [];
+}
+const server = new index_js_1.Server({ name: "kage-graph", version: "1.1.0" }, { capabilities: { tools: {} } });
+function listTools() {
+    return [
         {
             name: "kage_search",
             description: "Search the kage community knowledge graph for gotchas, patterns, configs, and architectural decisions across auth, database, payments, deployment, frontend, testing, and more. Returns node summaries ranked by relevance.",
@@ -84,16 +101,381 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
                 properties: {},
             },
         },
-    ],
+        {
+            name: "kage_recall",
+            description: "Recall repo-local Kage memory from .agent_memory packets. Returns an agent-ready context block plus ranked packet summaries.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string" },
+                    project_dir: { type: "string" },
+                    limit: { type: "number" },
+                    explain: { type: "boolean" },
+                    json: { type: "boolean" },
+                },
+                required: ["query", "project_dir"],
+            },
+        },
+        {
+            name: "kage_graph",
+            description: "Query the repo-local Kage knowledge graph. Returns typed, evidence-backed graph facts from entities, edges, and episodes.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    query: { type: "string" },
+                    limit: { type: "number" },
+                },
+                required: ["project_dir", "query"],
+            },
+        },
+        {
+            name: "kage_code_graph",
+            description: "Query the source-derived codebase graph: files, symbols, imports, calls, routes, tests, package scripts. This is generated from code, not learned memory.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    query: { type: "string" },
+                    limit: { type: "number" },
+                    json: { type: "boolean" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_metrics",
+            description: "Return concise Kage adoption and quality metrics: code graph counts, language/parser coverage, memory graph evidence coverage, pending/approved packets, validation state, and readiness score.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_quality",
+            description: "Return memory quality metrics: useful memory ratio, duplicate burden, stale/wrong feedback, evidence coverage, path grounding, and review queue size.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_benchmark",
+            description: "Return Kage proof metrics: runbook, bug-fix, decision and code-flow coverage, recall hit rate, estimated rediscovery avoided, tokens saved, and time-to-first-use.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_setup_agent",
+            description: "Generate MCP/setup instructions for Codex, Claude Code, Cursor, Windsurf, Gemini CLI, OpenCode, Cline, Goose, Roo Code, Kilo Code, Claude Desktop, Aider, or generic MCP.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", enum: kernel_js_1.SETUP_AGENTS },
+                    project_dir: { type: "string" },
+                    write: { type: "boolean" },
+                },
+                required: ["agent", "project_dir"],
+            },
+        },
+        {
+            name: "kage_verify_agent",
+            description: "Verify that Kage is truly active for the current agent: config, repo policy, indexes, recall, code graph, and this live MCP tool reachability.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", enum: kernel_js_1.SETUP_AGENTS },
+                    project_dir: { type: "string" },
+                },
+                required: ["agent", "project_dir"],
+            },
+        },
+        {
+            name: "kage_graph_visual",
+            description: "Export the repo-local Kage knowledge graph as Mermaid flowchart text for visual inspection.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    limit: { type: "number" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_branch_overlay",
+            description: "Build and return branch overlay metadata: branch, head, merge-base, changed files, and pending packet IDs.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_learn",
+            description: "Capture an actual reusable learning from the current session as repo-local memory. Prefer this over diff proposal when the agent knows what was learned.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    learning: { type: "string" },
+                    title: { type: "string" },
+                    type: { type: "string" },
+                    evidence: { type: "string" },
+                    verified_by: { type: "string" },
+                    tags: { type: "array", items: { type: "string" } },
+                    paths: { type: "array", items: { type: "string" } },
+                    stack: { type: "array", items: { type: "string" } },
+                },
+                required: ["project_dir", "learning"],
+            },
+        },
+        {
+            name: "kage_capture",
+            description: "Create a repo-local Kage memory packet immediately. Org/global promotion still requires explicit human review.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    title: { type: "string" },
+                    summary: { type: "string" },
+                    body: { type: "string" },
+                    type: { type: "string" },
+                    tags: { type: "array", items: { type: "string" } },
+                    paths: { type: "array", items: { type: "string" } },
+                    stack: { type: "array", items: { type: "string" } },
+                },
+                required: ["project_dir", "title", "body"],
+            },
+        },
+        {
+            name: "kage_observe",
+            description: "Store an automatic local observation event from an agent session. Observations are privacy-scanned, deduplicated, and never published automatically.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    type: { type: "string", enum: ["session_start", "user_prompt", "tool_use", "tool_result", "file_change", "command_result", "test_result", "session_end"] },
+                    session_id: { type: "string" },
+                    agent: { type: "string" },
+                    tool: { type: "string" },
+                    path: { type: "string" },
+                    command: { type: "string" },
+                    exit_code: { type: "number" },
+                    text: { type: "string" },
+                    summary: { type: "string" },
+                    timestamp: { type: "string" },
+                    metadata: { type: "object" },
+                },
+                required: ["project_dir", "type"],
+            },
+        },
+        {
+            name: "kage_distill",
+            description: "Distill stored observations for one session into repo-local memory candidates. Org/global promotion still requires explicit human review.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    session_id: { type: "string" },
+                },
+                required: ["project_dir", "session_id"],
+            },
+        },
+        {
+            name: "kage_feedback",
+            description: "Record usefulness feedback on an approved repo-local memory packet: helpful, wrong, or stale.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    packet_id: { type: "string" },
+                    kind: { type: "string", enum: ["helpful", "wrong", "stale"] },
+                },
+                required: ["project_dir", "packet_id", "kind"],
+            },
+        },
+        {
+            name: "kage_install_policy",
+            description: "Install or update the repo AGENTS.md policy that tells coding agents to use Kage automatically.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_validate",
+            description: "Validate repo-local Kage memory packets, pending packets, generated indexes, and sensitive-content checks.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_registry_recommend",
+            description: "Recommend documentation packs, skills, and optional MCPs for this repo based on its package metadata. Recommendations never install anything automatically.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_marketplace",
+            description: "Build a local marketplace manifest for recommended docs, skills, and MCP packs. This never installs anything automatically.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_org_status",
+            description: "Inspect the local org-memory inbox, approved packets, rejected packets, audit count, and registry path.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    org: { type: "string" },
+                },
+                required: ["project_dir", "org"],
+            },
+        },
+        {
+            name: "kage_org_upload_candidate",
+            description: "Upload an approved repo packet into the local org review inbox. This creates a candidate only; it does not approve org memory.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    org: { type: "string" },
+                    packet_id: { type: "string" },
+                },
+                required: ["project_dir", "org", "packet_id"],
+            },
+        },
+        {
+            name: "kage_org_recall",
+            description: "Recall approved local org memory. Repo-local recall should still take priority when results conflict.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    org: { type: "string" },
+                    query: { type: "string" },
+                    limit: { type: "number" },
+                    json: { type: "boolean" },
+                },
+                required: ["project_dir", "org", "query"],
+            },
+        },
+        {
+            name: "kage_layered_recall",
+            description: "Recall with Kage's priority order: branch > repo local > org > global. Org/global are included only when explicitly requested.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    query: { type: "string" },
+                    org: { type: "string" },
+                    include_global: { type: "boolean" },
+                    json: { type: "boolean" },
+                },
+                required: ["project_dir", "query"],
+            },
+        },
+        {
+            name: "kage_global_build",
+            description: "Build a local static global/CDN bundle from human-promoted public candidates and the marketplace manifest. This does not upload anywhere.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    org: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_promote_public_candidate",
+            description: "Create a sanitized local public-review candidate from an approved repo memory packet. This does not publish to the global graph.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    packet_id: { type: "string" },
+                },
+                required: ["project_dir", "packet_id"],
+            },
+        },
+        {
+            name: "kage_export_public_bundle",
+            description: "Export local public-review candidates as a static public bundle catalog. This still does not publish anywhere.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_review_artifact",
+            description: "Create a Markdown review artifact summarizing pending memory packets for PR or human review.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_propose_from_diff",
+            description: "Create or update a branch review summary and repo-local change-memory packet from local git status and diff metadata. Org/global promotion still requires explicit human review.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+    ];
+}
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: listTools(),
 }));
-server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
+async function callTool(name, args) {
     if (name === "kage_list_domains") {
         const catalog = await fetchJSON(`${BASE_URL}/catalog.json`);
         const lines = Object.entries(catalog.domains)
-            .filter(([, d]) => d.node_count > 0)
-            .sort(([, a], [, b]) => b.node_count - a.node_count)
-            .map(([domain, d]) => `**${domain}** — ${d.node_count} nodes | tags: ${d.top_tags.slice(0, 5).join(", ")}`);
+            .filter(([, d]) => domainNodeCount(d) > 0)
+            .sort(([, a], [, b]) => domainNodeCount(b) - domainNodeCount(a))
+            .map(([domain, d]) => `**${domain}** — ${domainNodeCount(d)} nodes | tags: ${domainTopTags(d).slice(0, 5).join(", ")}`);
         return {
             content: [
                 {
@@ -107,32 +489,28 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
         const query = String(args?.query ?? "");
         const domainFilter = args?.domain ? String(args.domain) : null;
         const catalog = await fetchJSON(`${BASE_URL}/catalog.json`);
-        // Pick domains to search
         let domainsToSearch;
         if (domainFilter) {
             domainsToSearch = [domainFilter];
         }
         else {
             domainsToSearch = Object.entries(catalog.domains)
-                .filter(([, d]) => d.node_count > 0)
+                .filter(([, d]) => domainNodeCount(d) > 0)
                 .map(([name, d]) => ({ name, score: scoreDomainMatch(query, d) }))
                 .sort((a, b) => b.score - a.score)
                 .slice(0, 3)
                 .filter((d) => d.score > 0)
                 .map((d) => d.name);
-            // Fall back to all non-empty domains if no tag match
             if (domainsToSearch.length === 0) {
                 domainsToSearch = Object.entries(catalog.domains)
-                    .filter(([, d]) => d.node_count > 0)
+                    .filter(([, d]) => domainNodeCount(d) > 0)
                     .map(([name]) => name);
             }
         }
-        // Fetch indexes in parallel
         const indexResults = await Promise.allSettled(domainsToSearch.map(async (domain) => {
             const index = await fetchJSON(`${BASE_URL}/domains/${domain}/index.json`);
             return { domain, nodes: index.nodes };
         }));
-        // Score and rank all nodes
         const scored = [];
         for (const result of indexResults) {
             if (result.status === "fulfilled") {
@@ -161,7 +539,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             return [
                 `### [${i + 1}] ${n.title}`,
                 `**Domain:** ${r.domain} | **Type:** ${n.type} | **Score:** ${n.score} | **Updated:** ${n.updated}`,
-                `**Tags:** ${n.tags.join(", ")}`,
+                `**Tags:** ${(n.tags ?? []).join(", ")}`,
                 n.summary ? `**Summary:** ${n.summary}` : "",
                 `**Fetch:** domain="${r.domain}" node_id="${n.id}"`,
             ]
@@ -185,10 +563,288 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
             content: [{ type: "text", text: content }],
         };
     }
+    if (name === "kage_recall") {
+        const result = (0, kernel_js_1.recall)(String(args?.project_dir ?? ""), String(args?.query ?? ""), Number(args?.limit ?? 5), Boolean(args?.explain));
+        return {
+            content: [{ type: "text", text: args?.json || args?.explain ? JSON.stringify(result, null, 2) : result.context_block }],
+        };
+    }
+    if (name === "kage_graph") {
+        const result = (0, kernel_js_1.queryGraph)(String(args?.project_dir ?? ""), String(args?.query ?? ""), Number(args?.limit ?? 10));
+        return {
+            content: [{ type: "text", text: result.context_block }],
+        };
+    }
+    if (name === "kage_code_graph") {
+        const projectDir = String(args?.project_dir ?? "");
+        const query = typeof args?.query === "string" ? args.query : "";
+        if (query) {
+            const result = (0, kernel_js_1.queryCodeGraph)(projectDir, query, Number(args?.limit ?? 10));
+            return {
+                content: [{ type: "text", text: args?.json ? JSON.stringify(result, null, 2) : result.context_block }],
+            };
+        }
+        const result = (0, kernel_js_1.buildCodeGraph)(projectDir);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_metrics") {
+        const result = (0, kernel_js_1.kageMetrics)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_quality") {
+        const result = (0, kernel_js_1.qualityReport)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_benchmark") {
+        const result = (0, kernel_js_1.benchmarkProject)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_setup_agent") {
+        const result = (0, kernel_js_1.setupAgent)(String(args?.agent ?? ""), String(args?.project_dir ?? ""), { write: Boolean(args?.write) });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_verify_agent") {
+        const result = (0, kernel_js_1.verifyAgentActivation)(String(args?.agent ?? ""), String(args?.project_dir ?? ""), { mcpToolReachable: true });
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_graph_visual") {
+        const result = (0, kernel_js_1.graphMermaid)(String(args?.project_dir ?? ""), Number(args?.limit ?? 40));
+        return {
+            content: [{ type: "text", text: `\`\`\`mermaid\n${result.mermaid}\n\`\`\`` }],
+        };
+    }
+    if (name === "kage_branch_overlay") {
+        const result = (0, kernel_js_1.buildBranchOverlay)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_learn") {
+        const result = (0, kernel_js_1.learn)({
+            projectDir: String(args?.project_dir ?? ""),
+            learning: String(args?.learning ?? ""),
+            title: args?.title ? String(args.title) : undefined,
+            type: args?.type ? String(args.type) : undefined,
+            evidence: args?.evidence ? String(args.evidence) : undefined,
+            verifiedBy: args?.verified_by ? String(args.verified_by) : undefined,
+            tags: arrayArg(args?.tags),
+            paths: arrayArg(args?.paths),
+            stack: arrayArg(args?.stack),
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? `Captured session learning: ${result.path}\nRepo-local memory is written immediately. Org/global promotion still requires explicit review.`
+                        : `Learning capture blocked:\n${result.errors.map((error) => `- ${error}`).join("\n")}`,
+                },
+            ],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_capture") {
+        const result = (0, kernel_js_1.capture)({
+            projectDir: String(args?.project_dir ?? ""),
+            title: String(args?.title ?? ""),
+            summary: args?.summary ? String(args.summary) : undefined,
+            body: String(args?.body ?? ""),
+            type: args?.type ? String(args.type) : undefined,
+            tags: arrayArg(args?.tags),
+            paths: arrayArg(args?.paths),
+            stack: arrayArg(args?.stack),
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? `Captured repo-local packet: ${result.path}\nOrg/global promotion still requires explicit review.`
+                        : `Capture blocked:\n${result.errors.map((error) => `- ${error}`).join("\n")}`,
+                },
+            ],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_observe") {
+        const projectDir = String(args?.project_dir ?? "");
+        const event = { ...args };
+        delete event.project_dir;
+        const result = (0, kernel_js_1.observe)(projectDir, event);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_distill") {
+        const result = (0, kernel_js_1.distillSession)(String(args?.project_dir ?? ""), String(args?.session_id ?? "default"));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_feedback") {
+        const result = (0, kernel_js_1.recordFeedback)(String(args?.project_dir ?? ""), String(args?.packet_id ?? ""), String(args?.kind ?? ""));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? `Recorded ${args?.kind} feedback for ${args?.packet_id}`
+                        : `Feedback failed:\n${result.errors.map((error) => `- ${error}`).join("\n")}`,
+                },
+            ],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_install_policy") {
+        const result = (0, kernel_js_1.installAgentPolicy)(String(args?.project_dir ?? ""));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `${result.created ? "Created" : result.updated ? "Updated" : "Already current"} agent policy: ${result.path}`,
+                },
+            ],
+        };
+    }
+    if (name === "kage_validate") {
+        const result = (0, kernel_js_1.validateProject)(String(args?.project_dir ?? ""));
+        const text = [
+            result.ok ? "Validation passed." : "Validation failed.",
+            result.errors.length ? `\nErrors:\n${result.errors.map((error) => `- ${error}`).join("\n")}` : "",
+            result.warnings.length ? `\nWarnings:\n${result.warnings.map((warning) => `- ${warning}`).join("\n")}` : "",
+        ].join("");
+        return {
+            content: [{ type: "text", text }],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_registry_recommend") {
+        const result = (0, kernel_js_1.registryRecommendations)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_marketplace") {
+        const result = (0, kernel_js_1.buildMarketplace)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_org_status") {
+        const result = (0, kernel_js_1.orgStatus)(String(args?.project_dir ?? ""), String(args?.org ?? "local"));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_org_upload_candidate") {
+        const result = (0, kernel_js_1.orgUploadPacket)(String(args?.project_dir ?? ""), String(args?.org ?? "local"), String(args?.packet_id ?? ""));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? `Created org review candidate: ${result.path}\nApprove explicitly with: kage org review --approve`
+                        : `Org upload blocked:\n${result.errors.map((error) => `- ${error}`).join("\n")}`,
+                },
+            ],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_org_recall") {
+        const result = (0, kernel_js_1.orgRecall)(String(args?.project_dir ?? ""), String(args?.org ?? "local"), String(args?.query ?? ""), Number(args?.limit ?? 5));
+        return {
+            content: [{ type: "text", text: args?.json ? JSON.stringify(result, null, 2) : result.context_block }],
+        };
+    }
+    if (name === "kage_layered_recall") {
+        const result = (0, kernel_js_1.layeredRecall)(String(args?.project_dir ?? ""), String(args?.query ?? ""), {
+            org: args?.org ? String(args.org) : undefined,
+            includeGlobal: Boolean(args?.include_global),
+        });
+        return {
+            content: [{ type: "text", text: args?.json ? JSON.stringify(result, null, 2) : result.context_block }],
+        };
+    }
+    if (name === "kage_global_build") {
+        const result = (0, kernel_js_1.buildGlobalCdnBundle)(String(args?.project_dir ?? ""), String(args?.org ?? "local"));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_promote_public_candidate") {
+        const result = (0, kernel_js_1.createPublicCandidate)(String(args?.project_dir ?? ""), String(args?.packet_id ?? ""));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? `Created local public-review candidate: ${result.path}\nThis does not publish until a human submits it.`
+                        : `Promotion blocked:\n${result.errors.map((error) => `- ${error}`).join("\n")}`,
+                },
+            ],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_export_public_bundle") {
+        const result = (0, kernel_js_1.exportPublicBundle)(String(args?.project_dir ?? ""));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? `Exported public bundle: ${result.path}\nPackets: ${result.packetCount}`
+                        : `Public bundle blocked:\n${result.errors.map((error) => `- ${error}`).join("\n")}`,
+                },
+            ],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_review_artifact") {
+        const result = (0, kernel_js_1.createReviewArtifact)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: `Wrote review artifact: ${result.path}\nPending packets: ${result.pending}` }],
+        };
+    }
+    if (name === "kage_propose_from_diff") {
+        const result = (0, kernel_js_1.proposeFromDiff)(String(args?.project_dir ?? ""));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.ok
+                        ? `Wrote branch review summary: ${result.path}\nCaptured repo-local change memory: ${result.packetPath ?? "(none)"}\nChanged files: ${result.changedFiles.join(", ")}`
+                        : `Proposal blocked:\n${result.errors.map((error) => `- ${error}`).join("\n")}`,
+                },
+            ],
+            isError: !result.ok,
+        };
+    }
     throw new Error(`Unknown tool: ${name}`);
+}
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return callTool(name, args);
 });
 async function main() {
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
 }
-main().catch(console.error);
+if (require.main === module) {
+    main().catch(console.error);
+}