memorix 1.9.4 → 1.9.6

package/src/cli/commands/serve-http.ts

@@ -22,6 +22,8 @@
 import { defineCommand } from 'citty';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { getHeapStatistics } from 'node:v8';
+import { monitorEventLoopDelay } from 'node:perf_hooks';
+import { timingSafeEqual } from 'node:crypto';
 import type { ObservationStore } from '../../store/obs-store.js';
 import { resolveToolProfile } from '../../server/tool-profile.js';
 import { scopeKnowledgeGraphToProject } from '../../memory/graph-scope.js';
@@ -39,6 +41,13 @@ import { mcpFileUriToPath } from '../mcp-root-path.js';
  */
 export const DEFAULT_SESSION_TIMEOUT_MS = 12 * 60 * 60 * 1000;
 export const EXPIRED_SESSION_TTL_MS = 10 * 60 * 1000;
+export const DEFAULT_HTTP_BODY_LIMIT_BYTES = 10 * 1024 * 1024;
+export const MAX_HTTP_BODY_LIMIT_BYTES = 64 * 1024 * 1024;
+export const MIN_HTTP_BODY_LIMIT_BYTES = 64 * 1024;
+export const MAX_PROJECT_CACHE_ENTRIES = 256;
+export const MAX_STORE_CACHE_ENTRIES = 32;
+export const DEFAULT_MAX_HTTP_SESSIONS = 64;
+export const MAX_HTTP_SESSIONS_LIMIT = 512;
 /** Pinned SDK protocol accepted internally while the HTTP boundary speaks the current stateless contract. */
 export const MCP_SDK_COMPAT_PROTOCOL_VERSION = '2025-11-25';
 
@@ -56,6 +65,109 @@ export function parseSessionTimeoutMs(raw: string | undefined): number {
   return Math.floor(parsed);
 }
 
+export function parseHttpBodyLimit(raw: string | undefined): number {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_HTTP_BODY_LIMIT_BYTES;
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < MIN_HTTP_BODY_LIMIT_BYTES) {
+    return DEFAULT_HTTP_BODY_LIMIT_BYTES;
+  }
+  return Math.min(parsed, MAX_HTTP_BODY_LIMIT_BYTES);
+}
+
+export function parseMaxHttpSessions(raw: string | undefined): number {
+  const value = raw?.trim();
+  if (!value) return DEFAULT_MAX_HTTP_SESSIONS;
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1) return DEFAULT_MAX_HTTP_SESSIONS;
+  return Math.min(parsed, MAX_HTTP_SESSIONS_LIMIT);
+}
+
+export function isLoopbackHost(host: string): boolean {
+  const normalized = host.trim().toLowerCase();
+  return normalized === 'localhost'
+    || normalized === '127.0.0.1'
+    || normalized === '::1'
+    || normalized === '[::1]';
+}
+
+export function validateHttpBindSecurity(
+  host: string,
+  env: NodeJS.ProcessEnv = process.env,
+): { requiresAuth: boolean; explicitlyUnauthenticated: boolean } {
+  const hasToken = Boolean(env.MEMORIX_HTTP_AUTH_TOKEN?.trim());
+  const explicitlyUnauthenticated = env.MEMORIX_HTTP_ALLOW_UNAUTHENTICATED_BIND === '1';
+  if (!isLoopbackHost(host) && !hasToken && !explicitlyUnauthenticated) {
+    throw new Error(
+      `[memorix] Refusing unauthenticated non-loopback HTTP bind on ${host}. `
+      + 'Set MEMORIX_HTTP_AUTH_TOKEN or explicitly set MEMORIX_HTTP_ALLOW_UNAUTHENTICATED_BIND=1.',
+    );
+  }
+  return { requiresAuth: hasToken, explicitlyUnauthenticated };
+}
+
+function isAuthorizedHttpRequest(req: IncomingMessage, token: string): boolean {
+  const header = req.headers.authorization;
+  if (!header) return false;
+  const match = /^Bearer\s+(.+)$/iu.exec(header);
+  if (!match) return false;
+  const provided = Buffer.from(match[1], 'utf8');
+  const expected = Buffer.from(token, 'utf8');
+  return provided.length === expected.length && timingSafeEqual(provided, expected);
+}
+
+export class HttpPayloadTooLargeError extends Error {
+  readonly statusCode = 413;
+
+  constructor(limitBytes: number) {
+    super(`Request body exceeds the ${limitBytes} byte limit.`);
+    this.name = 'HttpPayloadTooLargeError';
+  }
+}
+
+export function parseJsonBody(req: IncomingMessage, limitBytes: number): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    const contentLength = Number(req.headers['content-length']);
+    if (Number.isSafeInteger(contentLength) && contentLength > limitBytes) {
+      req.resume();
+      reject(new HttpPayloadTooLargeError(limitBytes));
+      return;
+    }
+
+    const chunks: Buffer[] = [];
+    let size = 0;
+    let settled = false;
+    const fail = (error: unknown) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+
+    req.on('data', (chunk: Buffer) => {
+      if (settled) return;
+      size += chunk.length;
+      if (size > limitBytes) {
+        req.removeAllListeners('data');
+        req.resume();
+        fail(new HttpPayloadTooLargeError(limitBytes));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => {
+      if (settled) return;
+      settled = true;
+      try {
+        const body = Buffer.concat(chunks).toString('utf-8');
+        resolve(body ? JSON.parse(body) : undefined);
+      } catch (error) {
+        reject(error);
+      }
+    });
+    req.on('error', fail);
+  });
+}
+
 export interface ServeHttpConfiguredDefaults {
   port?: number;
   transport?: 'stdio' | 'http';
@@ -132,7 +244,8 @@ export default defineCommand({
     // node:fs from being evaluated before their mock factories initialize.
     const { McpBindingStore } = await import('../../server/mcp-binding-store.js');
     const { MemoryFeedbackStore } = await import('../../memory/feedback.js');
-    const { createModernMcpBridge } = await import('../../server/modern-mcp-bridge.js');
+    const { createModernMcpRuntime, ModernMcpRuntimePool, withBusinessRuntimeQueue } = await import('../../server/modern-mcp-bridge.js');
+    const { acquireDatabase, evictIdleDatabases, getDatabaseStats } = await import('../../store/sqlite-db.js');
     const { createMcpHandler } = await import('@modelcontextprotocol/server');
     const { toNodeHandler } = await import('@modelcontextprotocol/node');
 
@@ -146,6 +259,14 @@ export default defineCommand({
     if (resolved.transportNotice) console.error(resolved.transportNotice);
     const port = resolved.port;
     const host = args.host || '127.0.0.1';
+    const bindSecurity = validateHttpBindSecurity(host);
+    const httpAuthToken = process.env.MEMORIX_HTTP_AUTH_TOKEN?.trim() || '';
+    if (bindSecurity.explicitlyUnauthenticated && !isLoopbackHost(host)) {
+      console.error(`[memorix] WARNING: HTTP control plane is unauthenticated on ${host}; keep it behind a private network or authenticated proxy.`);
+    }
+    if (bindSecurity.requiresAuth) {
+      console.error('[memorix] HTTP control plane authentication is enabled (Bearer token).');
+    }
     const toolProfile = resolveToolProfile({ explicit: args.mode, envValue: process.env.MEMORIX_MODE, fallback: 'team' });
 
     // Priority: explicit --cwd arg > MEMORIX_PROJECT_ROOT env > process.cwd().
@@ -176,31 +297,80 @@ export default defineCommand({
     console.error(`[memorix] HTTP transport starting on ${host}:${port}`);
     console.error(`[memorix] Project root: ${projectRoot}`);
     const sessionTimeoutMs = parseSessionTimeoutMs(process.env.MEMORIX_SESSION_TIMEOUT_MS);
+    const httpBodyLimitBytes = parseHttpBodyLimit(process.env.MEMORIX_HTTP_MAX_BODY_BYTES);
+    const maxHttpSessions = parseMaxHttpSessions(process.env.MEMORIX_MAX_HTTP_SESSIONS);
+    const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
+    eventLoopDelay.enable();
     console.error(
       sessionTimeoutMs === 0
         ? '[memorix] HTTP session idle timeout: disabled'
         : `[memorix] HTTP session idle timeout: ${Math.round(sessionTimeoutMs / 60000)}min (${sessionTimeoutMs}ms)`,
     );
+    console.error(`[memorix] HTTP session limit: ${maxHttpSessions}`);
 
     // Per-project TeamStore cache (Option B) — each dataDir gets its own TeamStore instance.
     // This ensures true isolation between projects in HTTP control-plane mode.
     const teamStoreCache = new Map<string, Awaited<ReturnType<typeof initTeamStore>>>();
+    const teamStoreLeases = new Map<string, { release: () => void }>();
     const { initTeamStore } = await import('../../team/team-store.js');
 
+    function cacheSet<K, V>(
+      cache: Map<K, V>,
+      key: K,
+      value: V,
+      limit: number,
+      onEvict?: (evictedKey: K, evictedValue: V) => void,
+    ): void {
+      cache.delete(key);
+      cache.set(key, value);
+      while (cache.size > limit) {
+        const oldest = cache.keys().next().value as K | undefined;
+        if (oldest === undefined) break;
+        const oldValue = cache.get(oldest);
+        cache.delete(oldest);
+        if (oldValue !== undefined) onEvict?.(oldest, oldValue);
+      }
+    }
+
     async function getTeamStore(dataDir: string) {
       const existing = teamStoreCache.get(dataDir);
-      if (existing) return existing;
-      const store = await initTeamStore(dataDir);
-      teamStoreCache.set(dataDir, store);
-      return store;
+      if (existing) {
+        cacheSet(teamStoreCache, dataDir, existing, MAX_STORE_CACHE_ENTRIES);
+        return existing;
+      }
+      const lease = acquireDatabase(dataDir);
+      try {
+        const store = await initTeamStore(dataDir);
+        teamStoreLeases.set(dataDir, lease);
+        cacheSet(teamStoreCache, dataDir, store, MAX_STORE_CACHE_ENTRIES, (evictedDataDir) => {
+          teamStoreLeases.get(evictedDataDir)?.release();
+          teamStoreLeases.delete(evictedDataDir);
+          evictIdleDatabases(MAX_STORE_CACHE_ENTRIES);
+        });
+        return store;
+      } catch (error) {
+        lease.release();
+        throw error;
+      }
     }
 
     // TeamStore is resolved per MCP session/project. Sharing one mutable
     // singleton here made project A's coordination state visible to project B
     // after a roots switch. The cache still reuses the same project's SQLite
     // handle without crossing project data directories.
+    const controlPlaneBaseDir = persistMod.getBaseDataDir();
+    const controlPlaneBaseLease = acquireDatabase(controlPlaneBaseDir);
     const statelessBindingStore = new McpBindingStore();
-    await statelessBindingStore.init(persistMod.getBaseDataDir());
+    await statelessBindingStore.init(controlPlaneBaseDir);
+    const modernRuntimePool = new ModernMcpRuntimePool(MAX_STORE_CACHE_ENTRIES);
+
+    async function resolveModernDataDir(root: string, persisted?: { dataDir?: string }): Promise<string> {
+      if (persisted?.dataDir) return persisted.dataDir;
+      const detected = detectorMod.detectProject(root);
+      return detected
+        ? persistMod.getProjectDataDir(detected.id)
+        : controlPlaneBaseDir;
+    }
 
     // Modern MCP (2026-07-28) is stateless at the protocol layer. The official
     // v2 handler owns discovery, per-request envelopes, result metadata,
@@ -211,32 +381,64 @@ export default defineCommand({
       const persisted = handleId ? statelessBindingStore.touch(handleId) : undefined;
       const requestedRoot = requestInfo?.headers.get('mcp-project-root') ?? undefined;
       const root = persisted?.projectRoot ?? requestedRoot ?? projectRoot;
-      return createModernMcpBridge({
-        projectRoot: root,
-        allowUntrackedFallback: false,
-        deferProjectInitUntilBound: true,
-        deferProjectRuntimeInit: true,
-        dashboardMode: 'control-plane',
-        dashboardPort: port,
-        toolProfile,
-      });
+      const dataDir = await resolveModernDataDir(root, persisted);
+      const runtimeKey = JSON.stringify([dataDir, root]);
+      // The SDK closes the per-request bridge after the response. The pool
+      // decrements the runtime reference there; the business runtime remains
+      // available for the next request for this project.
+      return modernRuntimePool.createBridge(runtimeKey, () => withBusinessRuntimeQueue(async () => {
+        const lease = acquireDatabase(dataDir);
+        try {
+          const runtime = await createModernMcpRuntime({
+            projectRoot: root,
+            allowUntrackedFallback: false,
+            deferProjectInitUntilBound: true,
+            deferProjectRuntimeInit: true,
+            dashboardMode: 'control-plane',
+            dashboardPort: port,
+            toolProfile,
+          });
+          const close = runtime.close.bind(runtime);
+          return {
+            ...runtime,
+            close: async () => {
+              try {
+                await close();
+              } finally {
+                lease.release();
+              }
+            },
+          };
+        } catch (error) {
+          lease.release();
+          throw error;
+        }
+      }));
     }, {
       // Legacy requests are routed to the existing sessionful implementation
       // below; this handler is strict modern-only by construction.
       legacy: 'reject',
       responseMode: 'auto',
+      onerror: error => {
+        const message = error instanceof Error ? error.message : String(error);
+        const stack = error instanceof Error ? error.stack : undefined;
+        console.error(`[memorix] modern MCP request failed: ${message}${stack ? `\n${stack}` : ''}`);
+      },
     });
     const modernNodeHandler = toNodeHandler(modernMcpHandler);
 
     type SessionState = {
       transport: InstanceType<typeof StreamableHTTPServerTransport>;
       server: Awaited<ReturnType<typeof createMemorixServer>>['server'];
+      activateProjectRuntime: Awaited<ReturnType<typeof createMemorixServer>>['activateProjectRuntime'];
       switchProject: Awaited<ReturnType<typeof createMemorixServer>>['switchProject'];
       binding: import('../../server/request-context.js').ProjectBindingController;
+      leases: Array<{ release: () => void }>;
     };
 
     // Session map: sessionId → transport + per-session server state
     const sessions = new Map<string, SessionState>();
+    let pendingSessionInitializations = 0;
 
     // Session activity tracking (for GC timeout)
     const sessionLastActivity = new Map<string, number>();
@@ -283,25 +485,6 @@ export default defineCommand({
       res.end(message);
     }
 
-    /**
-     * Parse JSON body from IncomingMessage
-     */
-    function parseBody(req: IncomingMessage): Promise<unknown> {
-      return new Promise((resolve, reject) => {
-        const chunks: Buffer[] = [];
-        req.on('data', (chunk: Buffer) => chunks.push(chunk));
-        req.on('end', () => {
-          try {
-            const body = Buffer.concat(chunks).toString('utf-8');
-            resolve(body ? JSON.parse(body) : undefined);
-          } catch (err) {
-            reject(err);
-          }
-        });
-        req.on('error', reject);
-      });
-    }
-
     /**
      * Patch ServerResponse for MCP compatibility with strict HTTP clients (rmcp/reqwest).
      *
@@ -442,7 +625,7 @@ export default defineCommand({
       // No Access-Control-Allow-Origin at all for disallowed origins —
       // browser will block the response (fail-closed).
       res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
-      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept, Mcp-Session-Id, Mcp-Project-Handle, Mcp-Project-Root, Mcp-Stateless, Last-Event-Id');
+      res.setHeader('Access-Control-Allow-Headers', 'Authorization, Content-Type, Accept, Mcp-Session-Id, Mcp-Project-Handle, Mcp-Project-Root, Mcp-Stateless, Last-Event-Id');
       res.setHeader('Access-Control-Expose-Headers', 'Mcp-Session-Id, Mcp-Project-Handle, Mcp-Protocol-Version, Mcp-Method, Mcp-Name');
       res.setHeader('Mcp-Protocol-Version', MCP_SDK_COMPAT_PROTOCOL_VERSION);
       res.setHeader('Mcp-Method', req.method || 'UNKNOWN');
@@ -454,7 +637,7 @@ export default defineCommand({
      */
     async function handlePost(req: IncomingMessage, res: ServerResponse) {
       const sessionId = req.headers['mcp-session-id'] as string | undefined;
-      const body = await parseBody(req);
+      const body = await parseJsonBody(req, httpBodyLimitBytes);
 
       // Keep the pre-2026 startup probe compatible. Older MCP clients sent a
       // claim-less server/discover before initialize and expect a plain JSON
@@ -525,7 +708,11 @@ export default defineCommand({
         // Existing session — route to its transport
         sessionLastActivity.set(sessionId, Date.now());
         patchMcpResponse(res);
-        await sessions.get(sessionId)!.transport.handleRequest(req, res, body);
+        const session = sessions.get(sessionId)!;
+        await withBusinessRuntimeQueue(async () => {
+          await session.activateProjectRuntime();
+          await session.transport.handleRequest(req, res, body);
+        });
         return;
       }
 
@@ -535,12 +722,34 @@ export default defineCommand({
       }
 
       if (!sessionId && isInitializeRequest(body)) {
+        if (sessions.size + pendingSessionInitializations >= maxHttpSessions) {
+          res.writeHead(429, {
+            'Content-Type': 'application/json',
+            'Retry-After': '5',
+          });
+          res.end(JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code: -32029, message: `HTTP session limit reached (${maxHttpSessions}). Retry after an existing session closes.` },
+            id: (body as { id?: string | number | null }).id ?? null,
+          }));
+          return;
+        }
+        pendingSessionInitializations++;
+        let pendingReservationReleased = false;
+        const releasePendingReservation = () => {
+          if (pendingReservationReleased) return;
+          pendingReservationReleased = true;
+          pendingSessionInitializations = Math.max(0, pendingSessionInitializations - 1);
+        };
+
         // New session — create transport + server
         let createdState: SessionState | null = null;
+        const sessionLeases: Array<{ release: () => void }> = [acquireDatabase(defaultDataDir)];
         const transport = new StreamableHTTPServerTransport({
           sessionIdGenerator: () => randomUUID(),
           enableJsonResponse: true,
           onsessioninitialized: (sid: string) => {
+            releasePendingReservation();
             if (createdState) sessions.set(sid, createdState);
             sessionLastActivity.set(sid, Date.now());
             // Defer log — only emit if session survives past SESSION_LOG_DELAY_MS
@@ -553,6 +762,7 @@ export default defineCommand({
         });
 
         transport.onclose = () => {
+          releasePendingReservation();
           const sid = transport.sessionId;
           if (sid) {
             // If the deferred init log hasn't fired yet, this was a short-lived probe
@@ -569,30 +779,53 @@ export default defineCommand({
             sessionLastActivity.delete(sid);
           }
           handleTransportClose();
+          for (const lease of sessionLeases) lease.release();
+          evictIdleDatabases(MAX_STORE_CACHE_ENTRIES);
         };
 
         // Legacy Mcp-Session-Id only routes requests. Project ownership lives
         // in this transport-neutral binding object, ready for stateless MCP.
         const binding = createProjectBindingController(projectRoot);
         // Create a fresh MCP server for this session (with shared team state)
-        const { server, switchProject, handleTransportClose } = await createMemorixServer(
-          projectRoot,
-          undefined,
-          undefined,
-          {
-            allowUntrackedFallback: false,
-            deferProjectInitUntilBound: true,
-            // Same as stdio: initialize/tools/list must not hydrate 40k+
-            // observations on the HTTP thread. /health and the LaunchAgent
-            // watchdog die if createMemorixServer blocks here.
-            deferProjectRuntimeInit: true,
-            dashboardMode: 'control-plane',
-            dashboardPort: port,
-            toolProfile,
-            projectBinding: binding,
-          },
-        );
-        createdState = { transport, server, switchProject, binding };
+        let server: Awaited<ReturnType<typeof createMemorixServer>>['server'];
+        let activateProjectRuntime: Awaited<ReturnType<typeof createMemorixServer>>['activateProjectRuntime'];
+        let handleTransportClose: Awaited<ReturnType<typeof createMemorixServer>>['handleTransportClose'];
+        let getProjectDataDirForSession: Awaited<ReturnType<typeof createMemorixServer>>['getProjectDataDir'];
+        let switchProject: Awaited<ReturnType<typeof createMemorixServer>>['switchProject'];
+        try {
+          ({ server, activateProjectRuntime, switchProject, handleTransportClose, getProjectDataDir: getProjectDataDirForSession } = await createMemorixServer(
+            projectRoot,
+            undefined,
+            undefined,
+            {
+              allowUntrackedFallback: false,
+              deferProjectInitUntilBound: true,
+              // Same as stdio: initialize/tools/list must not hydrate 40k+
+              // observations on the HTTP thread. /health and the LaunchAgent
+              // watchdog die if createMemorixServer blocks here.
+              deferProjectRuntimeInit: true,
+              dashboardMode: 'control-plane',
+              dashboardPort: port,
+              toolProfile,
+              projectBinding: binding,
+            },
+          ));
+        } catch (error) {
+          releasePendingReservation();
+          for (const lease of sessionLeases) lease.release();
+          throw error;
+        }
+        const switchProjectWithLease = async (newCwd: string, source?: import('../../server/request-context.js').ProjectBindingSource): Promise<boolean> => {
+          const before = getProjectDataDirForSession();
+          const changed = await switchProject(newCwd, source);
+          const after = getProjectDataDirForSession();
+          if (changed && after !== before) {
+            sessionLeases[0].release();
+            sessionLeases[0] = acquireDatabase(after);
+          }
+          return changed;
+        };
+        createdState = { transport, server, activateProjectRuntime, switchProject: switchProjectWithLease, binding, leases: sessionLeases };
         await server.connect(transport);
 
         const tryRootsSwitch = async () => {
@@ -639,7 +872,16 @@ export default defineCommand({
         } catch { /* optional */ }
 
         patchMcpResponse(res);
-        await transport.handleRequest(req, res, body);
+        try {
+          await withBusinessRuntimeQueue(async () => {
+            await activateProjectRuntime();
+            await transport.handleRequest(req, res, body);
+          });
+        } finally {
+          // A malformed probe can finish without creating a session; do not
+          // let it consume an admission slot forever.
+          if (!transport.sessionId) releasePendingReservation();
+        }
         // Do NOT proactively call listRoots() after session establishment —
         // this violates MCP SEP-2260 (server-initiated request must be associated
         // with a client request). Codex and other strict clients treat standalone
@@ -675,6 +917,8 @@ export default defineCommand({
         return;
       }
 
+      // GET may keep an SSE stream open; it does not enter the business tool
+      // layer and must not occupy the singleton runtime gate.
       await sessions.get(sessionId)!.transport.handleRequest(req, res);
     }
 
@@ -693,7 +937,7 @@ export default defineCommand({
         return;
       }
 
-      await sessions.get(sessionId)!.transport.handleRequest(req, res);
+      await withBusinessRuntimeQueue(() => sessions.get(sessionId)!.transport.handleRequest(req, res));
     }
 
     // Create HTTP server
@@ -725,8 +969,9 @@ export default defineCommand({
 
     // Cache resolved project data dirs to avoid repeated fs lookups
     const projectDataDirCache = new Map<string, string>();
-    projectDataDirCache.set(defaultProject.id, defaultDataDir);
+    cacheSet(projectDataDirCache, defaultProject.id, defaultDataDir, MAX_PROJECT_CACHE_ENTRIES);
     const dashboardObservationStores = new Map<string, ObservationStore>();
+    const dashboardStoreLeases = new Map<string, { release: () => void }>();
 
     /** Resolve ?project= query param to { projectId, projectName, dataDir } */
     async function resolveRequestProject(url: URL): Promise<{
@@ -742,7 +987,7 @@ export default defineCommand({
       let dataDir = projectDataDirCache.get(requestedId);
       if (!dataDir) {
         dataDir = await getProjectDataDir(requestedId);
-        projectDataDirCache.set(requestedId, dataDir);
+        cacheSet(projectDataDirCache, requestedId, dataDir, MAX_PROJECT_CACHE_ENTRIES);
       }
       const name = requestedId.split('/').pop() || requestedId;
       return { projectId: requestedId, projectName: name, dataDir };
@@ -750,11 +995,26 @@ export default defineCommand({
 
     async function getDashboardObservationStore(dataDir: string): Promise<ObservationStore> {
       const cached = dashboardObservationStores.get(dataDir);
-      if (cached) return cached;
+      if (cached) {
+        cacheSet(dashboardObservationStores, dataDir, cached, MAX_STORE_CACHE_ENTRIES);
+        return cached;
+      }
       const { createObservationStore } = await import('../../store/obs-store.js');
-      const store = await createObservationStore(dataDir);
-      dashboardObservationStores.set(dataDir, store);
-      return store;
+      const lease = acquireDatabase(dataDir);
+      try {
+        const store = await createObservationStore(dataDir);
+        dashboardStoreLeases.set(dataDir, lease);
+        cacheSet(dashboardObservationStores, dataDir, store, MAX_STORE_CACHE_ENTRIES, (evictedDataDir, evictedStore) => {
+          try { evictedStore.close(); } catch { /* best-effort */ }
+          dashboardStoreLeases.get(evictedDataDir)?.release();
+          dashboardStoreLeases.delete(evictedDataDir);
+          evictIdleDatabases(MAX_STORE_CACHE_ENTRIES);
+        });
+        return store;
+      } catch (error) {
+        lease.release();
+        throw error;
+      }
     }
 
     async function loadDashboardObservations(dataDir: string) {
@@ -861,7 +1121,7 @@ export default defineCommand({
             sendJson({ error: 'Maintenance actions require POST.' }, 405);
             return;
           }
-          const bodyValue = await parseBody(req);
+          const bodyValue = await parseJsonBody(req, Math.min(httpBodyLimitBytes, 1024 * 1024));
           const body = bodyValue && typeof bodyValue === 'object' && !Array.isArray(bodyValue)
             ? bodyValue as Record<string, unknown>
             : {};
@@ -1023,9 +1283,9 @@ export default defineCommand({
 
         if (apiPath === '/stats') {
           const { projectId: statsProjectId, dataDir: statsDataDir } = await resolveRequestProject(url);
-          const { initGraphStore, getGraphStore } = await import('../../store/graph-store.js');
-          await initGraphStore(statsDataDir);
-          const graph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
+          const { initGraphStore } = await import('../../store/graph-store.js');
+          const gStore = await initGraphStore(statsDataDir, statsProjectId);
+          const graph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
 
           const observations = await loadDashboardProjectObservations(statsDataDir, statsProjectId, 'active');
           const feedback = await loadProjectFeedback(statsDataDir, statsProjectId);
@@ -1210,9 +1470,9 @@ export default defineCommand({
 
         if (apiPath === '/graph') {
           const { projectId: graphProjectId, dataDir: graphDataDir } = await resolveRequestProject(url);
-          const { initGraphStore, getGraphStore } = await import('../../store/graph-store.js');
-          await initGraphStore(graphDataDir);
-          const fullGraph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
+          const { initGraphStore } = await import('../../store/graph-store.js');
+          const gStore = await initGraphStore(graphDataDir, graphProjectId);
+          const fullGraph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
 
           const allObs = await loadDashboardProjectObservations(graphDataDir, graphProjectId, 'active');
           const scoped = scopeKnowledgeGraphToProject(fullGraph, allObs);
@@ -1298,15 +1558,15 @@ export default defineCommand({
           const { projectId: kgProjectId, dataDir: kgDataDir } = await resolveRequestProject(url);
           const { generateKnowledgeGraph } = await import('../../wiki/knowledge-graph.js');
           const { initMiniSkillStore, getMiniSkillStore } = await import('../../store/mini-skill-store.js');
-          const { initGraphStore, getGraphStore } = await import('../../store/graph-store.js');
+          const { initGraphStore } = await import('../../store/graph-store.js');
 
           await initMiniSkillStore(kgDataDir);
-          await initGraphStore(kgDataDir);
+          const gStore = await initGraphStore(kgDataDir, kgProjectId);
 
           const allObs = await loadDashboardProjectObservations(kgDataDir, kgProjectId, 'active');
           const skills = await getMiniSkillStore().loadByProject(kgProjectId);
 
-          const fullGraph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
+          const fullGraph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
           const scoped = scopeKnowledgeGraphToProject(fullGraph, allObs);
 
           const graph = generateKnowledgeGraph({
@@ -1634,9 +1894,8 @@ export default defineCommand({
             await store.remove(obsId);
             // Sync: clean up graph entity references
             try {
-              const { initGraphStore, getGraphStore } = await import('../../store/graph-store.js');
-              await initGraphStore(delDataDir);
-              const gStore = getGraphStore();
+              const { initGraphStore } = await import('../../store/graph-store.js');
+              const gStore = await initGraphStore(delDataDir, delProjectId);
               const prefix = `[#${obsId}] `;
               const deletions: { entityName: string; observations: string[] }[] = [];
               for (const entity of gStore.loadEntities()) {
@@ -1653,9 +1912,9 @@ export default defineCommand({
         // GET /api/export — export observations as JSON
         if (apiPath === '/export') {
           const { projectId: expProjectId, projectName: expProjectName, dataDir: expDataDir } = await resolveRequestProject(url);
-          const { initGraphStore, getGraphStore } = await import('../../store/graph-store.js');
-          await initGraphStore(expDataDir);
-          const fullGraph = { entities: getGraphStore().loadEntities(), relations: getGraphStore().loadRelations() };
+          const { initGraphStore } = await import('../../store/graph-store.js');
+          const gStore = await initGraphStore(expDataDir, expProjectId);
+          const fullGraph = { entities: gStore.loadEntities(), relations: gStore.loadRelations() };
           const observations = await loadDashboardProjectObservations(expDataDir, expProjectId, 'active');
           const expStore = await getDashboardObservationStore(expDataDir);
           const nextId = await expStore.loadIdCounter();
@@ -1694,7 +1953,8 @@ export default defineCommand({
           }, 503);
           return;
         }
-        sendJson({ error: err instanceof Error ? err.message : 'Unknown error' }, 500);
+        const status = err instanceof HttpPayloadTooLargeError ? err.statusCode : 500;
+        sendJson({ error: err instanceof Error ? err.message : 'Unknown error' }, status);
       }
     }
 
@@ -1711,6 +1971,15 @@ export default defineCommand({
 
       const url = new URL(req.url || '/', `http://localhost:${port}`);
 
+      if (bindSecurity.requiresAuth && url.pathname !== '/health' && !isAuthorizedHttpRequest(req, httpAuthToken)) {
+        res.writeHead(401, {
+          'Content-Type': 'application/json',
+          'WWW-Authenticate': 'Bearer',
+        });
+        res.end(JSON.stringify({ error: 'Authentication required' }));
+        return;
+      }
+
       // Lightweight health check — responds immediately, no heavy init required.
       // This is the readiness signal for background start / status.
       if (url.pathname === '/health') {
@@ -1736,6 +2005,18 @@ export default defineCommand({
             arrayBuffers: memory.arrayBuffers,
             heapLimit: heap.heap_size_limit,
           },
+          sqlite: getDatabaseStats(),
+          sessions: {
+            active: sessions.size,
+            pending: pendingSessionInitializations,
+            limit: maxHttpSessions,
+          },
+          modernRuntime: modernRuntimePool.stats(),
+          eventLoop: {
+            meanMs: Number.isFinite(eventLoopDelay.mean) ? eventLoopDelay.mean / 1e6 : null,
+            p95Ms: eventLoopDelay.percentile(95) / 1e6,
+            maxMs: eventLoopDelay.max / 1e6,
+          },
           embedding: getEmbeddingRuntimeHealth(),
         }));
         return;
@@ -1792,10 +2073,15 @@ export default defineCommand({
         } catch (err) {
           console.error('[memorix] HTTP handler error:', err);
           if (!res.headersSent) {
-            res.writeHead(500, { 'Content-Type': 'application/json' });
+            const status = err instanceof HttpPayloadTooLargeError ? err.statusCode : 500;
+            const message = err instanceof Error ? err.message : 'Internal server error';
+            res.writeHead(status, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({
               jsonrpc: '2.0',
-              error: { code: -32603, message: 'Internal server error' },
+              error: {
+                code: status === 413 ? -32013 : -32603,
+                message: status === 413 ? message : 'Internal server error',
+              },
               id: null,
             }));
           }
@@ -1819,7 +2105,13 @@ export default defineCommand({
     httpServer.keepAliveTimeout = 60_000;
     httpServer.headersTimeout = 65_000;
 
-    httpServer.listen(port, host, () => {
+    const listenPromise = new Promise<void>((resolve, reject) => {
+      const onError = (error: Error) => {
+        if (typeof (httpServer as any).off === 'function') httpServer.off('listening', onListening);
+        reject(error);
+      };
+      const onListening = () => {
+      if (typeof (httpServer as any).off === 'function') httpServer.off('error', onError);
       httpReadyAt = new Date().toISOString();
       // Write readiness file — background start polls this for out-of-band readiness detection
       try {
@@ -1841,7 +2133,36 @@ export default defineCommand({
       // Fire-and-forget: background update check after server is fully started.
       // Default is notify-only. All output goes to stderr only. Failures never affect the server.
       import('../update-checker.js').then(m => m.checkForUpdates()).catch(() => {});
+        resolve();
+      };
+      if (typeof (httpServer as any).once === 'function') {
+        httpServer.once('error', onError);
+        httpServer.once('listening', onListening);
+        httpServer.listen(port, host);
+      } else {
+        // Lightweight test doubles may only implement listen(callback).
+        httpServer.listen(port, host, onListening);
+      }
     });
+    try {
+      await listenPromise;
+    } catch (error) {
+      console.error(`[memorix] HTTP server failed to listen on ${host}:${port}: ${error instanceof Error ? error.message : String(error)}`);
+      for (const store of dashboardObservationStores.values()) {
+        try { store.close(); } catch { /* best-effort */ }
+      }
+      dashboardObservationStores.clear();
+      for (const lease of dashboardStoreLeases.values()) lease.release();
+      dashboardStoreLeases.clear();
+      for (const lease of teamStoreLeases.values()) lease.release();
+      teamStoreLeases.clear();
+      controlPlaneBaseLease.release();
+      await modernRuntimePool.close();
+      eventLoopDelay.disable();
+      const { closeAllDatabases } = await import('../../store/sqlite-db.js');
+      closeAllDatabases();
+      throw error;
+    }
 
     // Session timeout GC — close sessions idle past the configured threshold.
     // MEMORIX_SESSION_TIMEOUT_MS lets operators work around HTTP clients that do
@@ -1851,6 +2172,9 @@ export default defineCommand({
       maybeProbeSummary(); // Flush suppressed probe count periodically
       const now = Date.now();
       forgetExpiredSessions(now);
+      statelessBindingStore.cleanupExpired(now);
+      evictIdleDatabases(MAX_STORE_CACHE_ENTRIES);
+      void modernRuntimePool.evictIdle();
       if (SESSION_TIMEOUT_MS === 0) return;
       for (const [sid, state] of sessions) {
         const lastActive = sessionLastActivity.get(sid) ?? 0;
@@ -1866,7 +2190,10 @@ export default defineCommand({
     gcInterval.unref(); // Don't prevent process exit
 
     // Graceful shutdown
+    let shutdownStarted = false;
     const shutdown = async () => {
+      if (shutdownStarted) return;
+      shutdownStarted = true;
       if (suppressedProbeCount > 0) {
         console.error(`[memorix] ${suppressedProbeCount} probe connection(s) suppressed during this session`);
       }
@@ -1883,6 +2210,10 @@ export default defineCommand({
         try { store.close(); } catch { /* best-effort */ }
       }
       dashboardObservationStores.clear();
+      for (const lease of dashboardStoreLeases.values()) lease.release();
+      dashboardStoreLeases.clear();
+      for (const lease of teamStoreLeases.values()) lease.release();
+      teamStoreLeases.clear();
       for (const [sid, state] of sessions) {
         try {
           await state.transport.close();
@@ -1891,7 +2222,20 @@ export default defineCommand({
           console.error(`[memorix] Error closing session ${sid}:`, err);
         }
       }
-      httpServer.close();
+      await modernRuntimePool.close();
+      clearInterval(gcInterval);
+      clearInterval(heartbeatInterval);
+      eventLoopDelay.disable();
+      await new Promise<void>((resolve) => {
+        if (!httpServer.listening) {
+          resolve();
+          return;
+        }
+        httpServer.close(() => resolve());
+      });
+      const { closeAllDatabases } = await import('../../store/sqlite-db.js');
+      controlPlaneBaseLease.release();
+      closeAllDatabases();
       process.exit(0);
     };
 
@@ -1943,6 +2287,13 @@ export default defineCommand({
 /** @internal */
 export const _testing = {
   DEFAULT_SESSION_TIMEOUT_MS,
+  DEFAULT_HTTP_BODY_LIMIT_BYTES,
+  MAX_HTTP_BODY_LIMIT_BYTES,
+  MIN_HTTP_BODY_LIMIT_BYTES,
   parseSessionTimeoutMs,
+  parseMaxHttpSessions,
+  parseHttpBodyLimit,
+  isLoopbackHost,
+  validateHttpBindSecurity,
   parseTcpPortOrReport,
 };