@massu/core 1.6.2 → 1.7.0

package/dist/cli.js

@@ -9542,14 +9542,33 @@ function domainFromWorkspace(pkg) {
     allowedImportsFrom: []
   };
 }
-function topLevelSrcSubdirs(root) {
-  const srcDir = join5(root, "src");
-  if (!existsSync7(srcDir)) return [];
-  try {
-    return readdirSync5(srcDir, { withFileTypes: true }).filter((e2) => e2.isDirectory() && !IGNORED_SUBDIRS.has(e2.name)).map((e2) => e2.name).sort();
-  } catch {
-    return [];
+function topLevelSrcSubdirs(root, sourceDirs) {
+  const effective = sourceDirs.length > 0 ? sourceDirs : ["src"];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rel of effective) {
+    const abs = join5(root, rel);
+    if (!existsSync7(abs)) continue;
+    try {
+      for (const e2 of readdirSync5(abs, { withFileTypes: true })) {
+        if (!e2.isDirectory()) continue;
+        if (IGNORED_SUBDIRS.has(e2.name)) continue;
+        seen.add(e2.name);
+      }
+    } catch {
+    }
+  }
+  return Array.from(seen).sort();
+}
+function flattenSourceDirs(sourceDirs) {
+  const flat = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(sourceDirs)) {
+    if (!entry) continue;
+    for (const dir of entry.source_dirs) {
+      if (dir === "." || dir === "") continue;
+      flat.add(dir);
+    }
   }
+  return Array.from(flat);
 }
 function inferDomains(projectRoot, monorepo, sourceDirs) {
   const domains = [];
@@ -9558,7 +9577,8 @@ function inferDomains(projectRoot, monorepo, sourceDirs) {
       domains.push(domainFromWorkspace(pkg));
     }
   } else {
-    const subdirs = topLevelSrcSubdirs(projectRoot);
+    const flat = flattenSourceDirs(sourceDirs);
+    const subdirs = topLevelSrcSubdirs(projectRoot, flat);
     for (const s of subdirs) {
       domains.push({
         name: titleCase(s),
@@ -13780,6 +13800,9 @@ function annotateToolDefinitions(defs) {
     };
   });
 }
+function isCloudFeatureAvailable() {
+  return getConfig().cloud?.enabled === true;
+}
 async function validateLicense(apiKey) {
   const keyHash = createHash4("sha256").update(apiKey).digest("hex");
   const memDb = getMemoryDb();
@@ -26723,7 +26746,8 @@ function getToolDefinitions() {
     ...getSecurityToolDefinitions(),
     ...getDependencyToolDefinitions(),
     // Enterprise layer (team knowledge, regression detection)
-    ...getTeamToolDefinitions(),
+    // P-A-003: team tools are cloud-gated — only listed when cloud.enabled is true.
+    ...isCloudFeatureAvailable() ? getTeamToolDefinitions() : [],
     ...getRegressionToolDefinitions(),
     // Knowledge layer (indexed .claude/ knowledge — rules, patterns, incidents)
     ...getKnowledgeToolDefinitions(),
@@ -26927,7 +26951,7 @@ async function handleToolCall(name, args2, dataDb, codegraphDb) {
         memDb.close();
       }
     }
-    if (isTeamTool(name)) {
+    if (isTeamTool(name) && isCloudFeatureAvailable()) {
       const memDb = getMemoryDb();
       try {
         return handleTeamToolCall(name, args2, memDb);
@@ -27759,111 +27783,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 +27963,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 +27979,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 +27996,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/dist/hooks/session-start.js

@@ -8360,14 +8360,33 @@ function domainFromWorkspace(pkg) {
     allowedImportsFrom: []
   };
 }
-function topLevelSrcSubdirs(root) {
-  const srcDir = join3(root, "src");
-  if (!existsSync5(srcDir)) return [];
-  try {
-    return readdirSync3(srcDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !IGNORED_SUBDIRS.has(e.name)).map((e) => e.name).sort();
-  } catch {
-    return [];
+function topLevelSrcSubdirs(root, sourceDirs) {
+  const effective = sourceDirs.length > 0 ? sourceDirs : ["src"];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rel of effective) {
+    const abs = join3(root, rel);
+    if (!existsSync5(abs)) continue;
+    try {
+      for (const e of readdirSync3(abs, { withFileTypes: true })) {
+        if (!e.isDirectory()) continue;
+        if (IGNORED_SUBDIRS.has(e.name)) continue;
+        seen.add(e.name);
+      }
+    } catch {
+    }
+  }
+  return Array.from(seen).sort();
+}
+function flattenSourceDirs(sourceDirs) {
+  const flat = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(sourceDirs)) {
+    if (!entry) continue;
+    for (const dir of entry.source_dirs) {
+      if (dir === "." || dir === "") continue;
+      flat.add(dir);
+    }
   }
+  return Array.from(flat);
 }
 function inferDomains(projectRoot, monorepo, sourceDirs) {
   const domains = [];
@@ -8376,7 +8395,8 @@ function inferDomains(projectRoot, monorepo, sourceDirs) {
       domains.push(domainFromWorkspace(pkg));
     }
   } else {
-    const subdirs = topLevelSrcSubdirs(projectRoot);
+    const flat = flattenSourceDirs(sourceDirs);
+    const subdirs = topLevelSrcSubdirs(projectRoot, flat);
     for (const s of subdirs) {
       domains.push({
         name: titleCase(s),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massu/core",
-  "version": "1.6.2",
+  "version": "1.7.0",
   "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/detect/domain-inferrer.ts

@@ -67,17 +67,69 @@ function domainFromWorkspace(pkg: WorkspacePackage): DomainConfig {
   };
 }
 
-function topLevelSrcSubdirs(root: string): string[] {
-  const srcDir = join(root, 'src');
-  if (!existsSync(srcDir)) return [];
-  try {
-    return readdirSync(srcDir, { withFileTypes: true })
-      .filter((e) => e.isDirectory() && !IGNORED_SUBDIRS.has(e.name))
-      .map((e) => e.name)
-      .sort();
-  } catch {
-    return [];
+/**
+ * Enumerate domain candidates under each detected source directory.
+ *
+ * The `sourceDirs` argument is the flattened, unique list of relative
+ * source paths produced upstream by the source-dir detector
+ * (`detectSourceDirs` in `source-dir-detector.ts`). For each path that
+ * exists under `root`, this function lists immediate subdirectories as
+ * candidate domain names. Hardcoded `src/` lookup was removed (plan
+ * `plan-1.7.0-cohesive-cleanup` P-B-002) — the function now consumes
+ * the detection pipeline's output verbatim, so projects whose source
+ * lives at non-`src/` paths (e.g. `lib/`, `apps/<x>/src/`) are no
+ * longer silently dropped.
+ *
+ * Empty `sourceDirs` is treated as a legacy single-repo `src/` lookup
+ * to preserve behavior for callers that pre-date the source-dir
+ * pipeline (CLI / test harnesses that hand-wire `inferDomains`).
+ *
+ * Returns deduplicated subdir names sorted alphabetically.
+ */
+function topLevelSrcSubdirs(root: string, sourceDirs: readonly string[]): string[] {
+  const effective = sourceDirs.length > 0 ? sourceDirs : ['src'];
+  const seen = new Set<string>();
+  for (const rel of effective) {
+    const abs = join(root, rel);
+    if (!existsSync(abs)) continue;
+    try {
+      for (const e of readdirSync(abs, { withFileTypes: true })) {
+        if (!e.isDirectory()) continue;
+        if (IGNORED_SUBDIRS.has(e.name)) continue;
+        seen.add(e.name);
+      }
+    } catch {
+      // skip directories that cannot be read; do not throw.
+    }
+  }
+  return Array.from(seen).sort();
+}
+
+/**
+ * Flatten a `SourceDirMap` into a unique, deduplicated list of relative
+ * source paths across all detected languages.
+ *
+ * Drops the root sentinels `.` and `''` — those are emitted by the
+ * source-dir-detector when source files live directly at the project
+ * root (e.g. Django's `manage.py` or Swift's `Package.swift`). Treating
+ * them as enumerable source dirs causes spurious top-level directory
+ * inclusion (Tests/, Sources/, etc.), which collides with the
+ * language-fallback path in `inferDomains`. Root-source repos rely on
+ * the language-fallback path to emit `{Python}` / `{Swift}` domains,
+ * NOT a fan-out of every root subdirectory.
+ *
+ * Order is not guaranteed — callers that need determinism must sort.
+ */
+function flattenSourceDirs(sourceDirs: SourceDirMap): string[] {
+  const flat = new Set<string>();
+  for (const entry of Object.values(sourceDirs)) {
+    if (!entry) continue;
+    for (const dir of entry.source_dirs) {
+      if (dir === '.' || dir === '') continue;
+      flat.add(dir);
+    }
   }
+  return Array.from(flat);
 }
 
 /**
@@ -100,8 +152,11 @@ export function inferDomains(
       domains.push(domainFromWorkspace(pkg));
     }
   } else {
-    // Single repo: suggest one domain per top-level src/<subdir>/ if src/ exists.
-    const subdirs = topLevelSrcSubdirs(projectRoot);
+    // Single repo: suggest one domain per top-level <sourceDir>/<subdir>/ for
+    // every detected source dir (formerly hardcoded to `src/` only — see
+    // P-B-002 in plan-1.7.0-cohesive-cleanup).
+    const flat = flattenSourceDirs(sourceDirs);
+    const subdirs = topLevelSrcSubdirs(projectRoot, flat);
     for (const s of subdirs) {
       domains.push({
         name: titleCase(s),

package/src/license.ts

@@ -203,6 +203,26 @@ export function annotateToolDefinitions(defs: ToolDefinition[]): ToolDefinition[
   });
 }
 
+// ============================================================
+// plan-1.7.0-cohesive-cleanup P-A-003: Cloud feature availability gate
+// ============================================================
+
+/**
+ * Whether cloud-gated tool surfaces (team knowledge, etc.) are exposed.
+ *
+ * Returns true ONLY when `massu.config.yaml` opts the workspace into the
+ * cloud feature surface via `cloud.enabled: true`. Defaults to false for
+ * fresh installs (the schema's `enabled` default is `false`).
+ *
+ * This is distinct from {@link isLicenseTool} (which matches tool NAMES);
+ * `isCloudFeatureAvailable` is a runtime feature-availability check used
+ * by `tools.ts` to gate team-tool registration and routing at the
+ * tools-list and dispatch boundaries.
+ */
+export function isCloudFeatureAvailable(): boolean {
+  return getConfig().cloud?.enabled === true;
+}
+
 // ============================================================
 // P3-005/P3-006/P3-007/P3-013: License validation & caching
 // ============================================================

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-12T04:00:39.397Z.
 // 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);
 });
 

package/src/tools.ts

@@ -38,7 +38,7 @@ import { getKnowledgeToolDefinitions, isKnowledgeTool, handleKnowledgeToolCall }
 import { getKnowledgeDb } from './knowledge-db.ts';
 import { getPythonToolDefinitions, isPythonTool, handlePythonToolCall } from './python-tools.ts';
 import { getConfig, getProjectRoot, getResolvedPaths } from './config.ts';
-import { getCurrentTier, getToolTier, isToolAllowed, annotateToolDefinitions, getLicenseToolDefinitions, isLicenseTool, handleLicenseToolCall } from './license.ts';
+import { getCurrentTier, getToolTier, isToolAllowed, annotateToolDefinitions, getLicenseToolDefinitions, isLicenseTool, handleLicenseToolCall, isCloudFeatureAvailable } from './license.ts';
 
 export interface ToolDefinition {
   name: string;
@@ -172,7 +172,8 @@ export function getToolDefinitions(): ToolDefinition[] {
     ...getSecurityToolDefinitions(),
     ...getDependencyToolDefinitions(),
     // Enterprise layer (team knowledge, regression detection)
-    ...getTeamToolDefinitions(),
+    // P-A-003: team tools are cloud-gated — only listed when cloud.enabled is true.
+    ...(isCloudFeatureAvailable() ? getTeamToolDefinitions() : []),
     ...getRegressionToolDefinitions(),
     // Knowledge layer (indexed .claude/ knowledge — rules, patterns, incidents)
     ...getKnowledgeToolDefinitions(),
@@ -410,7 +411,9 @@ export async function handleToolCall(
     }
 
     // Route enterprise layer tools
-    if (isTeamTool(name)) {
+    // P-A-003: team-tool dispatch gated on cloud availability; if a stale client
+    // still has the tool name cached, fall through to the unknown-tool branch.
+    if (isTeamTool(name) && isCloudFeatureAvailable()) {
       const memDb = getMemoryDb();
       try { return handleTeamToolCall(name, args, memDb); }
       finally { memDb.close(); }