@massu/core 1.6.2 → 1.6.3

package/dist/cli.js

@@ -27759,111 +27759,163 @@ var init_tool_db_needs = __esm({
   }
 });
 
-// src/server.ts
-var server_exports = {};
-import { readFileSync as readFileSync39 } from "fs";
-import { resolve as resolve32, dirname as dirname16 } from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-function resolveDbsForTool(toolName) {
-  const needs = getToolDbNeeds(toolName, getConfig().toolPrefix);
-  let dataDbResolved;
-  let codegraphDbResolved;
-  if (needs.includes("data")) {
-    if (!dataDbCache) dataDbCache = getDataDb();
-    dataDbResolved = dataDbCache;
-  }
-  if (needs.includes("codegraph")) {
-    if (!codegraphDbCache) codegraphDbCache = getCodeGraphDb();
-    codegraphDbResolved = codegraphDbCache;
-  }
-  return { needs, dataDb: dataDbResolved, codegraphDb: codegraphDbResolved };
-}
-async function handleRequest(request) {
-  const { method, params, id } = request;
-  switch (method) {
-    case "initialize": {
-      return {
-        jsonrpc: "2.0",
-        id: id ?? null,
-        result: {
-          protocolVersion: "2024-11-05",
-          capabilities: {
-            tools: {}
-          },
-          serverInfo: {
-            name: getConfig().toolPrefix || "massu",
-            version: PKG_VERSION
-          }
-        }
-      };
-    }
-    case "notifications/initialized": {
-      return { jsonrpc: "2.0", id: id ?? null, result: {} };
-    }
-    case "tools/list": {
-      const tools = getToolDefinitions();
-      return {
-        jsonrpc: "2.0",
-        id: id ?? null,
-        result: { tools }
-      };
-    }
-    case "tools/call": {
-      const toolName = params?.name;
-      const toolArgs = params?.arguments ?? {};
-      try {
-        const { dataDb: lDb, codegraphDb: cgDb } = resolveDbsForTool(toolName);
-        const result = await handleToolCall(toolName, toolArgs, lDb, cgDb);
+// src/server-dispatch.ts
+function createDispatcher(options) {
+  let codegraphDbCache = null;
+  let dataDbCache = null;
+  function resolveDbsForTool(toolName) {
+    const needs = getToolDbNeeds(toolName, getConfig().toolPrefix);
+    let dataDbResolved;
+    let codegraphDbResolved;
+    if (needs.includes("data")) {
+      if (!dataDbCache) dataDbCache = getDataDb();
+      dataDbResolved = dataDbCache;
+    }
+    if (needs.includes("codegraph")) {
+      if (!codegraphDbCache) codegraphDbCache = getCodeGraphDb();
+      codegraphDbResolved = codegraphDbCache;
+    }
+    return { needs, dataDb: dataDbResolved, codegraphDb: codegraphDbResolved };
+  }
+  async function handleRequest(request) {
+    const { method, params, id } = request;
+    switch (method) {
+      case "initialize": {
         return {
           jsonrpc: "2.0",
           id: id ?? null,
-          result
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: {
+              name: getConfig().toolPrefix || "massu",
+              version: options.serverInfoVersion
+            }
+          }
         };
-      } catch (err) {
-        if (err instanceof CodegraphDbNotInitializedError) {
-          return {
-            jsonrpc: "2.0",
-            id: id ?? null,
-            error: {
-              code: -32001,
-              message: `Tool requires CodeGraph database which is not initialized for this repo`,
-              data: {
-                remedy: "npx @colbymchenry/codegraph@0.7.4 init . && npx @colbymchenry/codegraph@0.7.4 index .",
-                codegraphDbPath: err.dbPath,
-                tool: toolName
+      }
+      case "notifications/initialized": {
+        return { jsonrpc: "2.0", id: id ?? null, result: {} };
+      }
+      case "tools/list": {
+        const tools = getToolDefinitions();
+        return { jsonrpc: "2.0", id: id ?? null, result: { tools } };
+      }
+      case "tools/call": {
+        const toolName = params?.name ?? "";
+        const toolArgs = params?.arguments ?? {};
+        try {
+          const { dataDb, codegraphDb } = resolveDbsForTool(toolName);
+          const result = await handleToolCall(toolName, toolArgs, dataDb, codegraphDb);
+          return { jsonrpc: "2.0", id: id ?? null, result };
+        } catch (err) {
+          if (err instanceof CodegraphDbNotInitializedError) {
+            return {
+              jsonrpc: "2.0",
+              id: id ?? null,
+              error: {
+                code: -32001,
+                message: "Tool requires CodeGraph database which is not initialized for this repo",
+                data: {
+                  remedy: "npx @colbymchenry/codegraph@0.7.4 init . && npx @colbymchenry/codegraph@0.7.4 index .",
+                  codegraphDbPath: err.dbPath,
+                  tool: toolName
+                }
               }
-            }
-          };
-        }
-        if (err instanceof UnknownToolError) {
-          return {
-            jsonrpc: "2.0",
-            id: id ?? null,
-            error: {
-              code: -32602,
-              message: `Unknown tool: ${err.toolName}`,
-              data: {
-                remedy: "Tool not registered in TOOL_DB_NEEDS manifest. See packages/core/src/tool-db-needs.ts.",
-                tool: toolName
+            };
+          }
+          if (err instanceof UnknownToolError) {
+            return {
+              jsonrpc: "2.0",
+              id: id ?? null,
+              error: {
+                code: -32602,
+                message: `Unknown tool: ${err.toolName}`,
+                data: {
+                  remedy: "Tool not registered in TOOL_DB_NEEDS manifest. See packages/core/src/tool-db-needs.ts.",
+                  tool: toolName
+                }
               }
-            }
-          };
+            };
+          }
+          throw err;
         }
-        throw err;
+      }
+      case "ping": {
+        return { jsonrpc: "2.0", id: id ?? null, result: {} };
+      }
+      default: {
+        return {
+          jsonrpc: "2.0",
+          id: id ?? null,
+          error: { code: -32601, message: `Method not found: ${method}` }
+        };
       }
     }
-    case "ping": {
-      return { jsonrpc: "2.0", id: id ?? null, result: {} };
+  }
+  async function processLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+    let request;
+    try {
+      request = JSON.parse(trimmed);
+    } catch (parseError) {
+      return {
+        response: {
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32700,
+            message: `Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`
+          }
+        },
+        emit: true
+      };
     }
-    default: {
+    try {
+      const response = await handleRequest(request);
+      return { response, emit: request.id !== void 0 };
+    } catch (error) {
       return {
-        jsonrpc: "2.0",
-        id: id ?? null,
-        error: { code: -32601, message: `Method not found: ${method}` }
+        response: {
+          jsonrpc: "2.0",
+          id: request.id ?? null,
+          error: {
+            code: -32603,
+            message: `Internal error: ${error instanceof Error ? error.message : String(error)}`
+          }
+        },
+        emit: true
       };
     }
   }
+  function closeCachedDbs() {
+    if (codegraphDbCache) {
+      codegraphDbCache.close();
+      codegraphDbCache = null;
+    }
+    if (dataDbCache) {
+      dataDbCache.close();
+      dataDbCache = null;
+    }
+  }
+  return { handleRequest, processLine, closeCachedDbs };
 }
+var init_server_dispatch = __esm({
+  "src/server-dispatch.ts"() {
+    "use strict";
+    init_db();
+    init_config();
+    init_tools();
+    init_tool_db_needs();
+  }
+});
+
+// src/server.ts
+var server_exports = {};
+import { readFileSync as readFileSync39 } from "fs";
+import { resolve as resolve32, dirname as dirname16 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function pruneMemoryOnStartup() {
   try {
     const memDb = getMemoryDb();
@@ -27887,16 +27939,13 @@ function pruneMemoryOnStartup() {
     );
   }
 }
-var __dirname4, PKG_VERSION, codegraphDbCache, dataDbCache, buffer;
+var __dirname4, PKG_VERSION, dispatcher, buffer;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
-    init_db();
-    init_config();
-    init_tools();
     init_memory_db();
     init_license();
-    init_tool_db_needs();
+    init_server_dispatch();
     __dirname4 = dirname16(fileURLToPath4(import.meta.url));
     PKG_VERSION = (() => {
       try {
@@ -27906,8 +27955,7 @@ var init_server = __esm({
         return "0.0.0";
       }
     })();
-    codegraphDbCache = null;
-    dataDbCache = null;
+    dispatcher = createDispatcher({ serverInfoVersion: PKG_VERSION });
     pruneMemoryOnStartup();
     getCurrentTier().then((tier) => {
       process.stderr.write(`massu: License tier: ${tier}
@@ -27924,46 +27972,16 @@ var init_server = __esm({
       buffer += chunk;
       let newlineIndex;
       while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
-        const line = buffer.slice(0, newlineIndex).trim();
+        const line = buffer.slice(0, newlineIndex);
         buffer = buffer.slice(newlineIndex + 1);
-        if (!line) continue;
-        let request = null;
-        try {
-          request = JSON.parse(line);
-        } catch (parseError) {
-          const errorResponse = {
-            jsonrpc: "2.0",
-            id: null,
-            error: {
-              code: -32700,
-              message: `Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`
-            }
-          };
-          process.stdout.write(JSON.stringify(errorResponse) + "\n");
-          continue;
-        }
-        try {
-          const response = await handleRequest(request);
-          if (request.id !== void 0) {
-            const responseStr = JSON.stringify(response);
-            process.stdout.write(responseStr + "\n");
-          }
-        } catch (error) {
-          const errorResponse = {
-            jsonrpc: "2.0",
-            id: request.id ?? null,
-            error: {
-              code: -32603,
-              message: `Internal error: ${error instanceof Error ? error.message : String(error)}`
-            }
-          };
-          process.stdout.write(JSON.stringify(errorResponse) + "\n");
+        const result = await dispatcher.processLine(line);
+        if (result && result.emit) {
+          process.stdout.write(JSON.stringify(result.response) + "\n");
         }
       }
     });
     process.stdin.on("end", () => {
-      if (codegraphDbCache) codegraphDbCache.close();
-      if (dataDbCache) dataDbCache.close();
+      dispatcher.closeCachedDbs();
       process.exit(0);
     });
     process.on("uncaughtException", (error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massu/core",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "type": "module",
   "description": "AI Engineering Governance MCP Server - Session memory, knowledge system, feature registry, code intelligence, rule enforcement, tiered tooling (12 free / 72 total), 55+ workflow commands, 11 agents, 20+ patterns",
   "main": "src/server.ts",

package/src/security/registry-pubkey.generated.ts

@@ -1,4 +1,4 @@
-// AUTO-GENERATED by scripts/bundle-pubkey.mjs at 2026-05-11T05:57:55.925Z.
+// AUTO-GENERATED by scripts/bundle-pubkey.mjs at 2026-05-11T22:54:34.471Z.
 // Source pem: packages/core/security/registry-pubkey.pem
 // RAW-bytes sha256: 3b6226d036c472e533110d11a7d0cd2773ce1d7d4f1003517d5bd69c5418ed4c
 // DO NOT EDIT — regenerate via `node scripts/bundle-pubkey.mjs` or

package/src/server-dispatch.ts

@@ -0,0 +1,225 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+/**
+ * MCP server dispatch logic — pure, factory-based, no module-level mutable state.
+ *
+ * Production (`server.ts`) calls `createDispatcher()` once at startup and wires
+ * its `processLine` into stdin. Tests call `createDispatcher()` per test for
+ * fresh DB cache state (no test bleed).
+ *
+ * Three error envelopes live here (CR-12 / plan-1.6.2-server-lazy-db-deps):
+ *   -32001  Tool needs CodeGraph but `.codegraph/codegraph.db` is missing
+ *           (CodegraphDbNotInitializedError → structured remedy data)
+ *   -32602  Tool not registered in `TOOL_DB_NEEDS` manifest
+ *           (UnknownToolError → points at tool-db-needs.ts)
+ *   -32603  Other internal errors raised by handleToolCall — request id
+ *           is preserved (NOT id:null, which is reserved for -32700 parse
+ *           failures per JSON-RPC §5.1).
+ */
+
+import type Database from 'better-sqlite3';
+import { getCodeGraphDb, getDataDb, CodegraphDbNotInitializedError } from './db.ts';
+import { getConfig } from './config.ts';
+import { getToolDefinitions, handleToolCall } from './tools.ts';
+import { getToolDbNeeds, UnknownToolError, type DbNeed } from './tool-db-needs.ts';
+
+export interface JsonRpcRequest {
+  jsonrpc: '2.0';
+  id?: number | string;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+export interface JsonRpcResponse {
+  jsonrpc: '2.0';
+  id: number | string | null;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+/** Per-line dispatch result. `emit=false` when the request was a notification (no id). */
+export interface ProcessLineResult {
+  response: JsonRpcResponse;
+  emit: boolean;
+}
+
+export interface DispatcherOptions {
+  /** Version string surfaced in `initialize.result.serverInfo.version`. */
+  serverInfoVersion: string;
+}
+
+export interface Dispatcher {
+  handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+  processLine(line: string): Promise<ProcessLineResult | null>;
+  closeCachedDbs(): void;
+}
+
+export function createDispatcher(options: DispatcherOptions): Dispatcher {
+  let codegraphDbCache: Database.Database | null = null;
+  let dataDbCache: Database.Database | null = null;
+
+  function resolveDbsForTool(toolName: string): {
+    needs: readonly DbNeed[];
+    dataDb?: Database.Database;
+    codegraphDb?: Database.Database;
+  } {
+    const needs = getToolDbNeeds(toolName, getConfig().toolPrefix);
+
+    let dataDbResolved: Database.Database | undefined;
+    let codegraphDbResolved: Database.Database | undefined;
+
+    if (needs.includes('data')) {
+      if (!dataDbCache) dataDbCache = getDataDb();
+      dataDbResolved = dataDbCache;
+    }
+
+    if (needs.includes('codegraph')) {
+      // Throws CodegraphDbNotInitializedError when .codegraph/codegraph.db is missing.
+      if (!codegraphDbCache) codegraphDbCache = getCodeGraphDb();
+      codegraphDbResolved = codegraphDbCache;
+    }
+
+    return { needs, dataDb: dataDbResolved, codegraphDb: codegraphDbResolved };
+  }
+
+  async function handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse> {
+    const { method, params, id } = request;
+
+    switch (method) {
+      case 'initialize': {
+        return {
+          jsonrpc: '2.0',
+          id: id ?? null,
+          result: {
+            protocolVersion: '2024-11-05',
+            capabilities: { tools: {} },
+            serverInfo: {
+              name: getConfig().toolPrefix || 'massu',
+              version: options.serverInfoVersion,
+            },
+          },
+        };
+      }
+
+      case 'notifications/initialized': {
+        return { jsonrpc: '2.0', id: id ?? null, result: {} };
+      }
+
+      case 'tools/list': {
+        const tools = getToolDefinitions();
+        return { jsonrpc: '2.0', id: id ?? null, result: { tools } };
+      }
+
+      case 'tools/call': {
+        const toolName = (params as { name?: string })?.name ?? '';
+        const toolArgs = (params as { arguments?: Record<string, unknown> })?.arguments ?? {};
+
+        try {
+          const { dataDb, codegraphDb } = resolveDbsForTool(toolName);
+          const result = await handleToolCall(toolName, toolArgs, dataDb, codegraphDb);
+          return { jsonrpc: '2.0', id: id ?? null, result };
+        } catch (err) {
+          if (err instanceof CodegraphDbNotInitializedError) {
+            return {
+              jsonrpc: '2.0',
+              id: id ?? null,
+              error: {
+                code: -32001,
+                message: 'Tool requires CodeGraph database which is not initialized for this repo',
+                data: {
+                  remedy: 'npx @colbymchenry/codegraph@0.7.4 init . && npx @colbymchenry/codegraph@0.7.4 index .',
+                  codegraphDbPath: err.dbPath,
+                  tool: toolName,
+                },
+              },
+            };
+          }
+          if (err instanceof UnknownToolError) {
+            return {
+              jsonrpc: '2.0',
+              id: id ?? null,
+              error: {
+                code: -32602,
+                message: `Unknown tool: ${err.toolName}`,
+                data: {
+                  remedy: 'Tool not registered in TOOL_DB_NEEDS manifest. See packages/core/src/tool-db-needs.ts.',
+                  tool: toolName,
+                },
+              },
+            };
+          }
+          throw err;
+        }
+      }
+
+      case 'ping': {
+        return { jsonrpc: '2.0', id: id ?? null, result: {} };
+      }
+
+      default: {
+        return {
+          jsonrpc: '2.0',
+          id: id ?? null,
+          error: { code: -32601, message: `Method not found: ${method}` },
+        };
+      }
+    }
+  }
+
+  async function processLine(line: string): Promise<ProcessLineResult | null> {
+    const trimmed = line.trim();
+    if (!trimmed) return null;
+
+    let request: JsonRpcRequest;
+    try {
+      request = JSON.parse(trimmed) as JsonRpcRequest;
+    } catch (parseError) {
+      // JSON-RPC §5.1: parse failure → -32700 + id:null (no id is extractable).
+      return {
+        response: {
+          jsonrpc: '2.0',
+          id: null,
+          error: {
+            code: -32700,
+            message: `Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+          },
+        },
+        emit: true,
+      };
+    }
+
+    try {
+      const response = await handleRequest(request);
+      // Notifications (no id) MUST NOT receive a response per JSON-RPC §4.1.
+      return { response, emit: request.id !== undefined };
+    } catch (error) {
+      // Request-processing failure: -32603 with the request id preserved.
+      // Specific subclasses (-32001/-32602) are handled inside tools/call.
+      return {
+        response: {
+          jsonrpc: '2.0',
+          id: request.id ?? null,
+          error: {
+            code: -32603,
+            message: `Internal error: ${error instanceof Error ? error.message : String(error)}`,
+          },
+        },
+        emit: true,
+      };
+    }
+  }
+
+  function closeCachedDbs(): void {
+    if (codegraphDbCache) {
+      codegraphDbCache.close();
+      codegraphDbCache = null;
+    }
+    if (dataDbCache) {
+      dataDbCache.close();
+      dataDbCache = null;
+    }
+  }
+
+  return { handleRequest, processLine, closeCachedDbs };
+}

package/src/server.ts

@@ -14,13 +14,9 @@
 import { readFileSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import type Database from 'better-sqlite3';
-import { getCodeGraphDb, getDataDb, CodegraphDbNotInitializedError } from './db.ts';
-import { getConfig, getResolvedPaths } from './config.ts';
-import { getToolDefinitions, handleToolCall } from './tools.ts';
 import { getMemoryDb, pruneOldConversationTurns, pruneOldObservations } from './memory-db.ts';
 import { getCurrentTier } from './license.ts';
-import { getToolDbNeeds, UnknownToolError, type DbNeed } from './tool-db-needs.ts';
+import { createDispatcher } from './server-dispatch.ts';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG_VERSION = (() => {
@@ -32,167 +28,7 @@ const PKG_VERSION = (() => {
   }
 })();
 
-interface JsonRpcRequest {
-  jsonrpc: '2.0';
-  id?: number | string;
-  method: string;
-  params?: Record<string, unknown>;
-}
-
-interface JsonRpcResponse {
-  jsonrpc: '2.0';
-  id: number | string | null;
-  result?: unknown;
-  error?: { code: number; message: string; data?: unknown };
-}
-
-// === Server state: lazy per-tool DB resolution ===
-//
-// Per plan-1.6.2-server-lazy-db-deps: DBs are opened ONLY when the
-// currently-dispatched tool declares it needs them in `TOOL_DB_NEEDS`.
-// Connections are cached at module scope so subsequent tool calls reuse
-// the open handle without re-opening (CodeGraph is read-only — safe to
-// share; Data DB has WAL journal — single-writer is fine).
-//
-// PRIOR DESIGN (eliminated 2026-05-10): `getDb()` eagerly opened BOTH
-// CodeGraph + Data on every `tools/call`, even for memory/audit/knowledge
-// tools that don't need codegraph. Missing `.codegraph/codegraph.db`
-// broke ALL tools. See `docs/plans/2026-05-10-server-lazy-db-deps.md`.
-
-let codegraphDbCache: Database.Database | null = null;
-let dataDbCache: Database.Database | null = null;
-
-/**
- * Resolve the SQLite connections a tool needs, opening cached singletons
- * lazily. Memory DB and Knowledge DB are opened per-call by their routed
- * handlers (existing pattern in tools.ts) — only CodeGraph + Data are
- * cached here.
- *
- * @throws {CodegraphDbNotInitializedError} when tool needs codegraph but
- *   `.codegraph/codegraph.db` is missing. Caller (handleRequest) catches
- *   and translates to a structured `-32001` JSON-RPC error.
- */
-function resolveDbsForTool(toolName: string): {
-  needs: readonly DbNeed[];
-  dataDb?: Database.Database;
-  codegraphDb?: Database.Database;
-} {
-  const needs = getToolDbNeeds(toolName, getConfig().toolPrefix);
-
-  let dataDbResolved: Database.Database | undefined;
-  let codegraphDbResolved: Database.Database | undefined;
-
-  if (needs.includes('data')) {
-    if (!dataDbCache) dataDbCache = getDataDb();
-    dataDbResolved = dataDbCache;
-  }
-
-  if (needs.includes('codegraph')) {
-    if (!codegraphDbCache) codegraphDbCache = getCodeGraphDb();  // throws CodegraphDbNotInitializedError on missing
-    codegraphDbResolved = codegraphDbCache;
-  }
-
-  return { needs, dataDb: dataDbResolved, codegraphDb: codegraphDbResolved };
-}
-
-async function handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse> {
-  const { method, params, id } = request;
-
-  switch (method) {
-    case 'initialize': {
-      return {
-        jsonrpc: '2.0',
-        id: id ?? null,
-        result: {
-          protocolVersion: '2024-11-05',
-          capabilities: {
-            tools: {},
-          },
-          serverInfo: {
-            name: getConfig().toolPrefix || 'massu',
-            version: PKG_VERSION,
-          },
-        },
-      };
-    }
-
-    case 'notifications/initialized': {
-      // Client acknowledges initialization - no response needed for notifications
-      return { jsonrpc: '2.0', id: id ?? null, result: {} };
-    }
-
-    case 'tools/list': {
-      const tools = getToolDefinitions();
-      return {
-        jsonrpc: '2.0',
-        id: id ?? null,
-        result: { tools },
-      };
-    }
-
-    case 'tools/call': {
-      const toolName = (params as { name: string })?.name;
-      const toolArgs = (params as { arguments?: Record<string, unknown> })?.arguments ?? {};
-
-      // Lazy per-tool DB resolution. Throws if tool needs codegraph and
-      // .codegraph/codegraph.db is missing; caught below and translated
-      // to a structured -32001 error preserving the request id.
-      try {
-        const { dataDb: lDb, codegraphDb: cgDb } = resolveDbsForTool(toolName);
-        const result = await handleToolCall(toolName, toolArgs, lDb, cgDb);
-        return {
-          jsonrpc: '2.0',
-          id: id ?? null,
-          result,
-        };
-      } catch (err) {
-        if (err instanceof CodegraphDbNotInitializedError) {
-          return {
-            jsonrpc: '2.0',
-            id: id ?? null,
-            error: {
-              code: -32001,
-              message: `Tool requires CodeGraph database which is not initialized for this repo`,
-              data: {
-                remedy: 'npx @colbymchenry/codegraph@0.7.4 init . && npx @colbymchenry/codegraph@0.7.4 index .',
-                codegraphDbPath: err.dbPath,
-                tool: toolName,
-              },
-            },
-          };
-        }
-        if (err instanceof UnknownToolError) {
-          return {
-            jsonrpc: '2.0',
-            id: id ?? null,
-            error: {
-              code: -32602,
-              message: `Unknown tool: ${err.toolName}`,
-              data: {
-                remedy: 'Tool not registered in TOOL_DB_NEEDS manifest. See packages/core/src/tool-db-needs.ts.',
-                tool: toolName,
-              },
-            },
-          };
-        }
-        // Other errors propagate to the outer catch in the stdio handler
-        throw err;
-      }
-    }
-
-    case 'ping': {
-      return { jsonrpc: '2.0', id: id ?? null, result: {} };
-    }
-
-    default: {
-      return {
-        jsonrpc: '2.0',
-        id: id ?? null,
-        error: { code: -32601, message: `Method not found: ${method}` },
-      };
-    }
-  }
-}
+const dispatcher = createDispatcher({ serverInfoVersion: PKG_VERSION });
 
 // === Startup: prune stale memory data (non-blocking) ===
 
@@ -244,62 +80,20 @@ process.stdin.on('data', async (chunk: string) => {
   // Process complete messages (newline-delimited JSON-RPC)
   let newlineIndex: number;
   while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
-    const line = buffer.slice(0, newlineIndex).trim();
+    const line = buffer.slice(0, newlineIndex);
     buffer = buffer.slice(newlineIndex + 1);
 
-    if (!line) continue;
-
-    // Two-phase error handling: separate JSON-parse failures (genuine
-    // -32700) from request-processing failures (-32603 Internal error,
-    // preserving the request id when parseable).
-    let request: JsonRpcRequest | null = null;
-    try {
-      request = JSON.parse(line) as JsonRpcRequest;
-    } catch (parseError) {
-      // Real JSON parse failure — -32700 per JSON-RPC §5.1, id MUST be null
-      // because we couldn't extract one.
-      const errorResponse: JsonRpcResponse = {
-        jsonrpc: '2.0',
-        id: null,
-        error: {
-          code: -32700,
-          message: `Parse error: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
-        },
-      };
-      process.stdout.write(JSON.stringify(errorResponse) + '\n');
-      continue;
-    }
-
-    try {
-      const response = await handleRequest(request);
-      // Don't send responses for notifications (no id)
-      if (request.id !== undefined) {
-        const responseStr = JSON.stringify(response);
-        process.stdout.write(responseStr + '\n');
-      }
-    } catch (error) {
-      // Request-processing failure — propagate the request id (not null).
-      // -32603 Internal error per JSON-RPC §5.1. Specific subclasses
-      // (codegraph-not-init, unknown-tool) are caught earlier in the
-      // tools/call handler and translated to structured -32001/-32602.
-      const errorResponse: JsonRpcResponse = {
-        jsonrpc: '2.0',
-        id: request.id ?? null,
-        error: {
-          code: -32603,
-          message: `Internal error: ${error instanceof Error ? error.message : String(error)}`,
-        },
-      };
-      process.stdout.write(JSON.stringify(errorResponse) + '\n');
+    const result = await dispatcher.processLine(line);
+    if (result && result.emit) {
+      process.stdout.write(JSON.stringify(result.response) + '\n');
     }
   }
 });
 
 process.stdin.on('end', () => {
-  // Clean up cached DB connections (Memory + Knowledge are per-call,
-  // already closed in their routing branches).
-  if (codegraphDbCache) codegraphDbCache.close();
-  if (dataDbCache) dataDbCache.close();
+  // Close cached CodeGraph + Data connections. Memory + Knowledge are
+  // per-call (closed inside their routing branches in tools.ts).
+  dispatcher.closeCachedDbs();
   process.exit(0);
 });