@hasna/mementos 0.14.40 → 0.14.41

package/LICENSE

@@ -1,3 +1,4 @@
+
                                  Apache License
                            Version 2.0, January 2004
                         http://www.apache.org/licenses/
@@ -175,7 +176,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2024 Andrei Hasna
+   Copyright 2026 Hasna, Inc.
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -25,6 +25,18 @@ mementos-mcp
 
 116 tools available.
 
+## HTTP mode
+
+Run a shared Streamable HTTP MCP server (stateless, `127.0.0.1` only):
+
+```bash
+mementos-mcp --http
+# or: MCP_HTTP=1 mementos-mcp
+# default port: 8824 (override with --port or MCP_HTTP_PORT)
+```
+
+Endpoints: `GET /health`, `POST /mcp` (Streamable HTTP).
+
 ## REST API
 
 ```bash

package/dist/cli/index.js

@@ -64425,6 +64425,9 @@ import chalk19 from "chalk";
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync, writeFileSync as writeFileSync2, unlinkSync, cpSync as cpSync2 } from "fs";
 import { homedir as homedir3 } from "os";
 import { basename, dirname as dirname3, join as join5, resolve as resolve13 } from "path";
+function isInMemoryDb2(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
 var DEFAULT_CONFIG = {
   default_scope: "private",
   default_category: "knowledge",
@@ -64596,6 +64599,9 @@ function getDbPath2() {
   }
   const envDbPath = process.env["HASNA_MEMENTOS_DB_PATH"] ?? process.env["MEMENTOS_DB_PATH"];
   if (envDbPath) {
+    if (isInMemoryDb2(envDbPath)) {
+      return envDbPath;
+    }
     const resolved = resolve13(envDbPath);
     ensureDir2(dirname3(resolved));
     return resolved;

package/dist/index.js

@@ -55359,6 +55359,9 @@ function logSearchQuery(query, resultCount, agentId, projectId, db) {
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, readdirSync, writeFileSync as writeFileSync2, unlinkSync, cpSync as cpSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { basename, dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+function isInMemoryDb2(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
 var DEFAULT_CONFIG = {
   default_scope: "private",
   default_category: "knowledge",
@@ -55530,6 +55533,9 @@ function getDbPath2() {
   }
   const envDbPath = process.env["HASNA_MEMENTOS_DB_PATH"] ?? process.env["MEMENTOS_DB_PATH"];
   if (envDbPath) {
+    if (isInMemoryDb2(envDbPath)) {
+      return envDbPath;
+    }
     const resolved = resolve2(envDbPath);
     ensureDir2(dirname2(resolved));
     return resolved;

package/dist/lib/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAA+B,MAAM,UAAU,CAAC;AAM5E,eAAO,MAAM,cAAc,EAAE,cA4B5B,CAAC;AA4DF,wBAAgB,UAAU,IAAI,cAAc,CAwC3C;AAwED,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAMhD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAQ1D;AAED,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAOvC;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOnD;AAED,wBAAgB,SAAS,IAAI,MAAM,CAgDlC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAA+B,MAAM,UAAU,CAAC;AAU5E,eAAO,MAAM,cAAc,EAAE,cA4B5B,CAAC;AA4DF,wBAAgB,UAAU,IAAI,cAAc,CAwC3C;AAwED,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAMhD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAQ1D;AAED,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAOvC;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOnD;AAED,wBAAgB,SAAS,IAAI,MAAM,CAmDlC"}

package/dist/mcp/http.d.ts

@@ -0,0 +1,17 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const MCP_HTTP_SERVICE_NAME = "mementos";
+export declare const DEFAULT_MCP_HTTP_PORT = 8867;
+export declare function isHttpMode(argv?: string[], env?: NodeJS.ProcessEnv): boolean;
+export declare function isStdioMode(argv?: string[], env?: NodeJS.ProcessEnv): boolean;
+export declare function resolveMcpHttpPort(argv?: string[], env?: NodeJS.ProcessEnv): number;
+export type McpHttpServerHandle = {
+    port: number;
+    host: string;
+    close: () => Promise<void>;
+};
+export declare function startMcpHttpServer(buildServer: () => McpServer, options?: {
+    port?: number;
+    host?: string;
+    serviceName?: string;
+}): Promise<McpHttpServerHandle>;
+//# sourceMappingURL=http.d.ts.map

package/dist/mcp/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/mcp/http.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAChD,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C,wBAAgB,UAAU,CACxB,IAAI,GAAE,MAAM,EAAiB,EAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAET;AAED,wBAAgB,WAAW,CACzB,IAAI,GAAE,MAAM,EAAiB,EAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAET;AAED,wBAAgB,kBAAkB,CAChC,IAAI,GAAE,MAAM,EAAiB,EAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,CASR;AAoBD,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAEF,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,SAAS,EAC5B,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,OAAO,CAAC,mBAAmB,CAAC,CAwE9B"}

package/dist/mcp/index.d.ts

@@ -2,4 +2,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 /** Exported so other modules can push channel notifications via the underlying Server. */
 export declare let mcpServer: McpServer | null;
+export declare function buildServer(): McpServer;
 //# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA4CpE,0FAA0F;AAC1F,eAAO,IAAI,SAAS,EAAE,SAAS,GAAG,IAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AA6CpE,0FAA0F;AAC1F,eAAO,IAAI,SAAS,EAAE,SAAS,GAAG,IAAW,CAAC;AAqB9C,wBAAgB,WAAW,IAAI,SAAS,CA4EvC"}

package/dist/mcp/index.js

@@ -14668,6 +14668,9 @@ var init_export_v1 = __esm(() => {
 import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2, unlinkSync, cpSync as cpSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { basename as basename2, dirname as dirname4, join as join6, resolve as resolve3 } from "path";
+function isInMemoryDb2(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -14774,6 +14777,9 @@ function getDbPath2() {
   }
   const envDbPath = process.env["HASNA_MEMENTOS_DB_PATH"] ?? process.env["MEMENTOS_DB_PATH"];
   if (envDbPath) {
+    if (isInMemoryDb2(envDbPath)) {
+      return envDbPath;
+    }
     const resolved = resolve3(envDbPath);
     ensureDir2(dirname4(resolved));
     return resolved;
@@ -68285,74 +68291,174 @@ function registerConsolidationTools(server) {
   });
 }
 
+// src/mcp/http.ts
+import { createServer } from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+var MCP_HTTP_SERVICE_NAME = "mementos";
+var DEFAULT_MCP_HTTP_PORT = 8867;
+function isStdioMode(argv = process.argv, env = process.env) {
+  return argv.includes("--stdio") || env.MCP_STDIO === "1";
+}
+function resolveMcpHttpPort(argv = process.argv, env = process.env) {
+  const portIdx = argv.indexOf("--port");
+  if (portIdx !== -1 && argv[portIdx + 1]) {
+    return parsePort(argv[portIdx + 1], "--port");
+  }
+  if (env.MCP_HTTP_PORT) {
+    return parsePort(env.MCP_HTTP_PORT, "MCP_HTTP_PORT");
+  }
+  return DEFAULT_MCP_HTTP_PORT;
+}
+function parsePort(raw, source) {
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    throw new Error(`Invalid ${source} value "${raw}". Expected 0-65535.`);
+  }
+  return parsed;
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const text3 = Buffer.concat(chunks).toString("utf8");
+  if (!text3)
+    return;
+  return JSON.parse(text3);
+}
+async function startMcpHttpServer(buildServer, options) {
+  const host = options?.host ?? "127.0.0.1";
+  const requestedPort = options?.port ?? resolveMcpHttpPort();
+  const serviceName = options?.serviceName ?? MCP_HTTP_SERVICE_NAME;
+  const httpServer = createServer(async (req, res) => {
+    try {
+      const url2 = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+      if (req.method === "GET" && url2.pathname === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", name: serviceName }));
+        return;
+      }
+      if (url2.pathname !== "/mcp") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+        return;
+      }
+      const server = buildServer();
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined
+      });
+      await server.connect(transport);
+      let parsedBody;
+      if (req.method === "POST") {
+        parsedBody = await readJsonBody(req);
+      }
+      await transport.handleRequest(req, res, parsedBody);
+      res.on("close", () => {
+        transport.close();
+        server.close();
+      });
+    } catch (error40) {
+      console.error(`[${serviceName}-mcp] HTTP error:`, error40);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal server error" },
+          id: null
+        }));
+      }
+    }
+  });
+  await new Promise((resolve6, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(requestedPort, host, () => resolve6());
+  });
+  const addr = httpServer.address();
+  const port = typeof addr === "object" && addr ? addr.port : requestedPort;
+  console.error(`[${serviceName}-mcp] Streamable HTTP listening on http://${host}:${port}/mcp`);
+  return {
+    port,
+    host,
+    close: () => new Promise((resolve6, reject) => {
+      httpServer.close((err) => err ? reject(err) : resolve6());
+    })
+  };
+}
+
 // src/mcp/index.ts
 import { createRequire } from "module";
 var _require = createRequire(import.meta.url);
 var _pkg = _require("../../package.json");
 var mcpServer = null;
-var server = new McpServer({
-  name: "mementos",
-  version: _pkg.version
-}, {
-  capabilities: {
-    experimental: { "claude/channel": {} }
-  },
-  instructions: `Mementos is the persistent memory layer for AI agents. It stores, searches, and manages memories across sessions and projects.
-
-When running with --dangerously-load-development-channels, mementos will proactively push relevant memories into your conversation via channel notifications. These appear as <channel source="mementos"> tags. They contain memories activated by your current task context \u2014 use them to inform your work. You don't need to call memory_inject when auto-inject is active.`
-});
-mcpServer = server;
 function hasFlag(...flags) {
   return process.argv.some((arg) => flags.includes(arg));
 }
 function printHelp() {
   process.stdout.write(`Usage: mementos-mcp [options]
 
-Mementos MCP server (stdio transport)
+Mementos MCP server (stdio transport by default)
 
 Options:
+  --http           Serve MCP over Streamable HTTP (127.0.0.1)
+  --port <number>  HTTP port (default: 8824, env: MCP_HTTP_PORT)
   -h, --help       Show help
   -V, --version    Show version
 `);
 }
-registerMemoryCrudTools(server);
-registerMemoryHistoryTools(server);
-registerMemoryHealthTools(server);
-registerMemoryValidationTools(server);
-registerMemorySearchTools(server);
-registerMemoryLifecycleTools(server);
-registerMemorySyncTools(server);
-registerMemoryStatsTools(server);
-registerMemoryAuditTools(server);
-registerMemoryIoTools(server);
-registerMemoryInjectTools(server);
-registerEntityTools(server);
-registerRelationTools(server);
-registerGraphQueryTools(server);
-registerAgentTools(server);
-registerProjectTools(server);
-registerBulkTools(server);
-registerLockTools(server);
-registerFocusTools(server);
-registerHookTools(server);
-registerSynthesisTools(server);
-registerAutoMemoryTools(server);
-registerSessionTools(server);
-registerUtilityTools(server);
-registerSystemTools(server);
-registerConsolidationTools(server);
-server.resource("memories", "mementos://memories", { description: "All active memories", mimeType: "application/json" }, async () => {
-  const memories = listMemories({ status: "active", limit: 1000 });
-  return { contents: [{ uri: "mementos://memories", text: JSON.stringify(memories, null, 2), mimeType: "application/json" }] };
-});
-server.resource("agents", "mementos://agents", { description: "All registered agents", mimeType: "application/json" }, async () => {
-  const agents = listAgents();
-  return { contents: [{ uri: "mementos://agents", text: JSON.stringify(agents, null, 2), mimeType: "application/json" }] };
-});
-server.resource("projects", "mementos://projects", { description: "All registered projects", mimeType: "application/json" }, async () => {
-  const projects = listProjects();
-  return { contents: [{ uri: "mementos://projects", text: JSON.stringify(projects, null, 2), mimeType: "application/json" }] };
-});
+function buildServer() {
+  const server = new McpServer({
+    name: "mementos",
+    version: _pkg.version
+  }, {
+    capabilities: {
+      experimental: { "claude/channel": {} }
+    },
+    instructions: `Mementos is the persistent memory layer for AI agents. It stores, searches, and manages memories across sessions and projects.
+
+When running with --dangerously-load-development-channels, mementos will proactively push relevant memories into your conversation via channel notifications. These appear as <channel source="mementos"> tags. They contain memories activated by your current task context \u2014 use them to inform your work. You don't need to call memory_inject when auto-inject is active.`
+  });
+  registerMemoryCrudTools(server);
+  registerMemoryHistoryTools(server);
+  registerMemoryHealthTools(server);
+  registerMemoryValidationTools(server);
+  registerMemorySearchTools(server);
+  registerMemoryLifecycleTools(server);
+  registerMemorySyncTools(server);
+  registerMemoryStatsTools(server);
+  registerMemoryAuditTools(server);
+  registerMemoryIoTools(server);
+  registerMemoryInjectTools(server);
+  registerEntityTools(server);
+  registerRelationTools(server);
+  registerGraphQueryTools(server);
+  registerAgentTools(server);
+  registerProjectTools(server);
+  registerBulkTools(server);
+  registerLockTools(server);
+  registerFocusTools(server);
+  registerHookTools(server);
+  registerSynthesisTools(server);
+  registerAutoMemoryTools(server);
+  registerSessionTools(server);
+  registerUtilityTools(server);
+  registerSystemTools(server);
+  registerMementosStorageTools(server);
+  registerConsolidationTools(server);
+  server.resource("memories", "mementos://memories", { description: "All active memories", mimeType: "application/json" }, async () => {
+    const memories = listMemories({ status: "active", limit: 1000 });
+    return { contents: [{ uri: "mementos://memories", text: JSON.stringify(memories, null, 2), mimeType: "application/json" }] };
+  });
+  server.resource("agents", "mementos://agents", { description: "All registered agents", mimeType: "application/json" }, async () => {
+    const agents = listAgents();
+    return { contents: [{ uri: "mementos://agents", text: JSON.stringify(agents, null, 2), mimeType: "application/json" }] };
+  });
+  server.resource("projects", "mementos://projects", { description: "All registered projects", mimeType: "application/json" }, async () => {
+    const projects = listProjects();
+    return { contents: [{ uri: "mementos://projects", text: JSON.stringify(projects, null, 2), mimeType: "application/json" }] };
+  });
+  mcpServer = server;
+  return server;
+}
 async function ensureRestServerRunning() {
   try {
     const res = await fetch("http://127.0.0.1:19428/api/memories?limit=0", {
@@ -68378,6 +68484,16 @@ async function ensureRestServerRunning() {
     } catch {}
   }
 }
+async function prepareMcpRuntime() {
+  try {
+    const warning = getPrimaryMachineStartupWarning(getDatabase());
+    if (warning) {
+      console.warn(`[mementos-mcp] ${warning}`);
+    }
+  } catch {}
+  await ensureRestServerRunning();
+  loadWebhooksFromDb();
+}
 async function main() {
   if (hasFlag("--help", "-h")) {
     printHelp();
@@ -68388,37 +68504,45 @@ async function main() {
 `);
     return;
   }
-  try {
-    const warning = getPrimaryMachineStartupWarning(getDatabase());
-    if (warning) {
-      console.warn(`[mementos-mcp] ${warning}`);
-    }
-  } catch {}
-  await ensureRestServerRunning();
-  loadWebhooksFromDb();
-  const transport = new StdioServerTransport;
-  registerMementosStorageTools(server);
-  await server.connect(transport);
-  const autoProject = detectProject();
-  startAutoInject({
-    server,
-    project_id: autoProject?.id,
-    project_name: autoProject?.name,
-    cwd: process.cwd()
-  }).catch(() => {});
+  await prepareMcpRuntime();
+  if (isStdioMode()) {
+    const server = buildServer();
+    const transport = new StdioServerTransport;
+    await server.connect(transport);
+    const autoProject = detectProject();
+    startAutoInject({
+      server,
+      project_id: autoProject?.id,
+      project_name: autoProject?.name,
+      cwd: process.cwd()
+    }).catch(() => {});
+    process.on("SIGINT", () => {
+      stopAutoInject();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      stopAutoInject();
+      process.exit(0);
+    });
+    return;
+  }
+  const handle = await startMcpHttpServer(buildServer, {
+    port: resolveMcpHttpPort()
+  });
   process.on("SIGINT", () => {
-    stopAutoInject();
-    process.exit(0);
+    handle.close().finally(() => process.exit(0));
   });
   process.on("SIGTERM", () => {
-    stopAutoInject();
-    process.exit(0);
+    handle.close().finally(() => process.exit(0));
+  });
+}
+if (import.meta.main) {
+  main().catch((error40) => {
+    console.error("MCP server error:", error40);
+    process.exit(1);
   });
 }
-main().catch((error40) => {
-  console.error("MCP server error:", error40);
-  process.exit(1);
-});
 export {
-  mcpServer
+  mcpServer,
+  buildServer
 };

package/dist/server/index.js

@@ -5954,7 +5954,7 @@ __export(exports_database, {
 });
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, cpSync as cpSync2 } from "fs";
 import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
-function isInMemoryDb(path) {
+function isInMemoryDb2(path) {
   return path === ":memory:" || path.startsWith("file::memory:");
 }
 function findNearestMementosDb(startDir) {
@@ -6011,7 +6011,7 @@ function getDbPath2() {
   return join3(home, ".hasna", "mementos", "mementos.db");
 }
 function ensureDir2(filePath) {
-  if (isInMemoryDb(filePath))
+  if (isInMemoryDb2(filePath))
     return;
   const dir = dirname2(resolve2(filePath));
   if (!existsSync2(dir)) {
@@ -55997,6 +55997,9 @@ import { join as join5, resolve as resolve4, sep } from "path";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, cpSync } from "fs";
 import { homedir } from "os";
 import { basename, dirname, join, resolve } from "path";
+function isInMemoryDb(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
 function findFileWalkingUp(filename) {
   let dir = process.cwd();
   while (true) {
@@ -56063,6 +56066,9 @@ function getDbPath() {
   }
   const envDbPath = process.env["HASNA_MEMENTOS_DB_PATH"] ?? process.env["MEMENTOS_DB_PATH"];
   if (envDbPath) {
+    if (isInMemoryDb(envDbPath)) {
+      return envDbPath;
+    }
     const resolved = resolve(envDbPath);
     ensureDir(dirname(resolved));
     return resolved;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/mementos",
-  "version": "0.14.40",
+  "version": "0.14.41",
   "description": "Universal memory system for AI agents - CLI + MCP server + library API",
   "type": "module",
   "main": "dist/index.js",
@@ -35,7 +35,7 @@
     "build": "bun run clean && bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk --external @modelcontextprotocol/sdk && bun build src/mcp/index.ts --outdir dist/mcp --target bun --external @modelcontextprotocol/sdk && bun build src/server/index.ts --outdir dist/server --target bun && bun build src/index.ts src/storage.ts --outdir dist --target bun && bun build src/sdk/index.ts --outdir dist/sdk --target bun && tsc --emitDeclarationOnly --outDir dist",
     "prepare": "bun run build",
     "typecheck": "tsc --noEmit",
-    "test": "bun test",
+    "test": "bun test --isolate --timeout=10000",
     "dev:cli": "bun run src/cli/index.tsx",
     "dev:mcp": "bun run src/mcp/index.ts",
     "dev:serve": "bun run src/server/index.ts",