@memoraone/mcp 0.1.53 → 0.1.54

package/dist/cli.cjs

@@ -231,7 +231,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.53",
+      version: "0.1.54",
       type: "module",
       main: "dist/index.cjs",
       exports: {
@@ -531,7 +531,7 @@ async function acquireLocalLock(lockName, options = {}) {
             `[memoraone-mcp] Failed to acquire lock ${lockName} after ${maxRetries} retries`
           );
         }
-        await new Promise((resolve44) => setTimeout(resolve44, retryDelayMs));
+        await new Promise((resolve45) => setTimeout(resolve45, retryDelayMs));
         continue;
       }
       throw err;
@@ -1092,9 +1092,9 @@ var init_memoraClient = __esm({
 });
 
 // src/localState/localConnectClient.ts
-async function requestJson(baseUrl, method, path48, options = {}) {
+async function requestJson(baseUrl, method, path49, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const url = `${baseUrl.replace(/\/+$/, "")}${path48.startsWith("/") ? path48 : `/${path48}`}`;
+  const url = `${baseUrl.replace(/\/+$/, "")}${path49.startsWith("/") ? path49 : `/${path49}`}`;
   const res = await fetchImpl(url, {
     method,
     headers: {
@@ -1511,7 +1511,10 @@ async function reconcileResolvedBindingWithDisk(cached, options = {}) {
     );
   }
   const workspaceRoot = path10.resolve(record.workspaceRoot);
-  const identity = await captureRootFilesystemIdentity(workspaceRoot);
+  const identity = await captureRootFilesystemIdentity(
+    workspaceRoot,
+    options.identityDeps
+  );
   if (!identitiesMatch(record.filesystemIdentity, identity)) {
     throw new ReconnectRequiredError(
       "[memoraone-mcp] Workspace filesystem identity changed. Run: memoraone-mcp connect <code>"
@@ -3918,7 +3921,7 @@ function formatOptionalJetBrainsHandshakeUnavailableDetail(detail) {
 async function verifyJetBrainsMcpHandshake(options) {
   const timeoutMs = options.timeoutMs ?? 15e3;
   const { server } = options;
-  return new Promise((resolve44) => {
+  return new Promise((resolve45) => {
     let settled = false;
     const finish = (ok, detail, optionalUnavailable) => {
       if (settled) return;
@@ -3928,7 +3931,7 @@ async function verifyJetBrainsMcpHandshake(options) {
         child.kill();
       } catch {
       }
-      resolve44({ ok, detail, optionalUnavailable });
+      resolve45({ ok, detail, optionalUnavailable });
     };
     const child = (0, import_node_child_process4.spawn)(server.command, [...server.args], {
       env: { ...process.env, ...server.env },
@@ -12961,13 +12964,13 @@ function writeEvent(event, stdoutWrite) {
 }
 function delay(ms, signal) {
   if (ms <= 0 || signal?.aborted) return Promise.resolve();
-  return new Promise((resolve44) => {
+  return new Promise((resolve45) => {
     const timer = setTimeout(finish, ms);
     const onAbort = () => finish();
     function finish() {
       clearTimeout(timer);
       signal?.removeEventListener("abort", onAbort);
-      resolve44();
+      resolve45();
     }
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -13270,13 +13273,180 @@ var init_runtimeIdentityCommand = __esm({
   }
 });
 
+// src/gatewayConfig.ts
+function resolveGatewayPort(env2 = process.env) {
+  const raw = env2.MEMORAONE_GATEWAY_PORT?.trim();
+  if (!raw) return GATEWAY_PORT;
+  const parsed2 = Number.parseInt(raw, 10);
+  if (!Number.isInteger(parsed2) || parsed2 < 1 || parsed2 > 65535) {
+    throw new Error(
+      `[memoraone-mcp] Invalid MEMORAONE_GATEWAY_PORT=${JSON.stringify(raw)} (expected 1\u201365535)`
+    );
+  }
+  return parsed2;
+}
+function resolveGatewayListenConfig(env2 = process.env) {
+  return {
+    host: GATEWAY_HOST,
+    port: resolveGatewayPort(env2)
+  };
+}
+function getGatewayBaseUrl(env2 = process.env) {
+  const { host, port } = resolveGatewayListenConfig(env2);
+  return `http://${host}:${port}`;
+}
+function getGatewayHealthUrl(env2 = process.env) {
+  return `${getGatewayBaseUrl(env2)}${GATEWAY_HEALTH_PATH}`;
+}
+function buildGatewaySpawnArgs(scriptPath) {
+  return [scriptPath, "--gateway"];
+}
+var path47, GATEWAY_HOST, GATEWAY_PORT, GATEWAY_LOCK_NAME, GATEWAY_HEALTH_PATH;
+var init_gatewayConfig = __esm({
+  "src/gatewayConfig.ts"() {
+    path47 = __toESM(require("path"), 1);
+    GATEWAY_HOST = "127.0.0.1";
+    GATEWAY_PORT = 17355;
+    GATEWAY_LOCK_NAME = "gateway";
+    GATEWAY_HEALTH_PATH = "/health";
+  }
+});
+
+// src/gatewayEnsure.ts
+var gatewayEnsure_exports = {};
+__export(gatewayEnsure_exports, {
+  cliEnsureGateway: () => cliEnsureGateway,
+  ensureGateway: () => ensureGateway,
+  probeGatewayHealth: () => probeGatewayHealth
+});
+async function probeGatewayHealth(env2 = process.env) {
+  const url = getGatewayHealthUrl(env2);
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(750) });
+    if (!res.ok) {
+      return { healthy: false, reason: `HTTP ${res.status}` };
+    }
+    const body = await res.json();
+    if (body?.ok !== true || typeof body.pid !== "number") {
+      return { healthy: false, reason: "invalid health body" };
+    }
+    return { healthy: true, body: { ok: true, pid: body.pid } };
+  } catch (err) {
+    return { healthy: false, reason: String(err) };
+  }
+}
+function defaultSpawnGateway(cliPath, env2) {
+  return new Promise((resolve45, reject) => {
+    let child;
+    try {
+      child = (0, import_node_child_process7.spawn)(process.execPath, buildGatewaySpawnArgs(cliPath), {
+        detached: true,
+        stdio: "ignore",
+        env: { ...env2 }
+      });
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    child.once("error", reject);
+    child.unref();
+    setImmediate(() => resolve45());
+  });
+}
+async function waitUntilHealthy(probe, env2, waitTimeoutMs, pollIntervalMs) {
+  const started = Date.now();
+  let lastReason = "not started";
+  while (Date.now() - started < waitTimeoutMs) {
+    const result = await probe(env2);
+    if (result.healthy) return result.body;
+    lastReason = result.reason;
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+  }
+  const { host, port } = resolveGatewayListenConfig(env2);
+  throw new Error(
+    `[memoraone-mcp] Gateway did not become healthy on ${host}:${port} within ${waitTimeoutMs}ms (${lastReason})`
+  );
+}
+async function ensureGateway(options = {}) {
+  const env2 = options.env ?? process.env;
+  const probe = options.probe ?? probeGatewayHealth;
+  const spawnGateway = options.spawnGateway ?? defaultSpawnGateway;
+  const waitTimeoutMs = options.waitTimeoutMs ?? 1e4;
+  const pollIntervalMs = options.pollIntervalMs ?? 50;
+  const listen = resolveGatewayListenConfig(env2);
+  const lockRetryDelayMs = options.lockRetryDelayMs ?? 50;
+  const lockMaxRetries = options.lockMaxRetries ?? Math.ceil(waitTimeoutMs / lockRetryDelayMs) + 40;
+  const first = await probe(env2);
+  if (first.healthy) {
+    return { reused: true, pid: first.body.pid, listen };
+  }
+  return withLocalLock(
+    GATEWAY_LOCK_NAME,
+    async () => {
+      const second = await probe(env2);
+      if (second.healthy) {
+        return { reused: true, pid: second.body.pid, listen };
+      }
+      const cliPath = options.cliPath ?? await resolveBuiltCliPathAsync() ?? process.argv[1];
+      if (!cliPath) {
+        throw new Error("[memoraone-mcp] Unable to resolve CLI path to spawn gateway");
+      }
+      log(`spawning gateway on ${listen.host}:${listen.port} via ${cliPath}`);
+      await spawnGateway(cliPath, env2);
+      const body = await waitUntilHealthy(probe, env2, waitTimeoutMs, pollIntervalMs);
+      return { reused: false, pid: body.pid, listen };
+    },
+    {
+      homeDir: options.homeDir,
+      maxRetries: lockMaxRetries,
+      retryDelayMs: lockRetryDelayMs,
+      // Hold can be long while waiting for health; keep stale threshold above wait.
+      maxLockAgeMs: Math.max(3e4, waitTimeoutMs + 5e3)
+    }
+  );
+}
+async function cliEnsureGateway(_argv = [], options = {}) {
+  try {
+    const result = await ensureGateway(options);
+    const mode = result.reused ? "reused" : "started";
+    process.stdout.write(
+      `${JSON.stringify({
+        status: "ok",
+        mode,
+        pid: result.pid,
+        host: result.listen.host,
+        port: result.listen.port
+      })}
+`
+    );
+    return 0;
+  } catch (err) {
+    process.stderr.write(`[memoraone-mcp] ensure-gateway failed: ${String(err)}
+`);
+    return 1;
+  }
+}
+var import_node_child_process7, log;
+var init_gatewayEnsure = __esm({
+  "src/gatewayEnsure.ts"() {
+    import_node_child_process7 = require("child_process");
+    init_localLocks();
+    init_resolveBuiltCliPath();
+    init_gatewayConfig();
+    log = (msg) => {
+      process.stderr.write(`[memoraone-mcp][ensure-gateway] ${msg}
+`);
+    };
+  }
+});
+
 // src/bridgeClientRoots.ts
 function isInitializeDebugEnabled(env2 = process.env) {
   return TRUTHY.has(String(env2.MEMORAONE_DEBUG_INIT ?? "").trim().toLowerCase());
 }
-function logInitializeDebug(log, env2, msg) {
+function logInitializeDebug(log2, env2, msg) {
   if (isInitializeDebugEnabled(env2)) {
-    log(`[init-debug] ${msg}`);
+    log2(`[init-debug] ${msg}`);
   }
 }
 function clientDeclaresRootsCapability(params) {
@@ -13326,7 +13496,7 @@ function extractRootsUrisFromListResult(result) {
 }
 async function requestClientRootsListUris(options) {
   const env2 = options.env ?? process.env;
-  const log = options.log ?? (() => {
+  const log2 = options.log ?? (() => {
   });
   const requestId = nextBridgeRequestId++;
   const deferredLines = [];
@@ -13337,7 +13507,7 @@ async function requestClientRootsListUris(options) {
     params: {}
   };
   logInitializeDebug(
-    log,
+    log2,
     env2,
     `sending roots/list id=${requestId} clientDeclaresRoots=${clientDeclaresRootsCapability(options.initializeParams)}`
   );
@@ -13356,12 +13526,12 @@ async function requestClientRootsListUris(options) {
     try {
       message = JSON.parse(trimmed);
     } catch (err) {
-      logInitializeDebug(log, env2, `ignored non-JSON line while waiting for roots/list: ${String(err)}`);
+      logInitializeDebug(log2, env2, `ignored non-JSON line while waiting for roots/list: ${String(err)}`);
       continue;
     }
     if (message.id !== requestId) {
       logInitializeDebug(
-        log,
+        log2,
         env2,
         `deferred JSON-RPC while waiting for roots/list id=${requestId}: ${trimmed.slice(0, 200)}`
       );
@@ -13374,7 +13544,7 @@ async function requestClientRootsListUris(options) {
       );
     }
     const uris = extractRootsUrisFromListResult(message.result);
-    logInitializeDebug(log, env2, `roots/list id=${requestId} returned ${uris.length}: ${JSON.stringify(uris)}`);
+    logInitializeDebug(log2, env2, `roots/list id=${requestId} returned ${uris.length}: ${JSON.stringify(uris)}`);
     return { uris, deferredLines };
   }
 }
@@ -13410,8 +13580,8 @@ var init_bridgeClientRoots = __esm({
         if (this.closed) {
           return null;
         }
-        return new Promise((resolve44) => {
-          this.waiters.push(resolve44);
+        return new Promise((resolve45) => {
+          this.waiters.push(resolve45);
         });
       }
       /** Re-queue lines read during an intermediate protocol step (e.g. roots/list) for the main bridge loop. */
@@ -13480,7 +13650,7 @@ function collectPluginStartupBindingRoots(options) {
     if (raw === void 0 || raw === null || raw.trim() === "") {
       return;
     }
-    const resolved = path47.resolve(raw);
+    const resolved = path48.resolve(raw);
     if (seen.has(resolved)) {
       return;
     }
@@ -13529,11 +13699,11 @@ async function isRetryablePluginStartupBindingError(err, options = {}) {
   return false;
 }
 function defaultSleep(ms) {
-  return new Promise((resolve44) => {
-    setTimeout(resolve44, ms);
+  return new Promise((resolve45) => {
+    setTimeout(resolve45, ms);
   });
 }
-async function waitForPluginStartupBinding(resolve44, options = {}) {
+async function waitForPluginStartupBinding(resolve45, options = {}) {
   const now = options.now ?? Date.now;
   const sleep = options.sleep ?? defaultSleep;
   const timeoutMs = options.timeoutMs ?? PLUGIN_STARTUP_BINDING_WAIT_TIMEOUT_MS;
@@ -13543,7 +13713,7 @@ async function waitForPluginStartupBinding(resolve44, options = {}) {
   let lastError;
   while (true) {
     try {
-      const binding = await resolve44();
+      const binding = await resolve45();
       if (waitingLogged) {
         options.log?.(
           `local MemoraOne binding available after Cursor plugin pairing (${now() - startedAt}ms)`
@@ -13587,10 +13757,10 @@ async function waitForPluginStartupBinding(resolve44, options = {}) {
     }
   }
 }
-var path47, MEMORAONE_PLUGIN_ENV, MEMORAONE_CURSOR_PLUGIN, PLUGIN_STARTUP_BINDING_WAIT_TIMEOUT_MS, PLUGIN_STARTUP_BINDING_WAIT_INTERVAL_MS, UNBOUND_MESSAGE_MARKERS, CREDENTIALS_MISSING_MARKER, PLUGIN_STARTUP_SETUP_REQUIRED;
+var path48, MEMORAONE_PLUGIN_ENV, MEMORAONE_CURSOR_PLUGIN, PLUGIN_STARTUP_BINDING_WAIT_TIMEOUT_MS, PLUGIN_STARTUP_BINDING_WAIT_INTERVAL_MS, UNBOUND_MESSAGE_MARKERS, CREDENTIALS_MISSING_MARKER, PLUGIN_STARTUP_SETUP_REQUIRED;
 var init_pluginStartupBindingWait = __esm({
   "src/pluginStartupBindingWait.ts"() {
-    path47 = __toESM(require("path"), 1);
+    path48 = __toESM(require("path"), 1);
     init_initializeBinding();
     init_bindingStore();
     init_resolveLocalBinding();
@@ -13826,15 +13996,15 @@ function extractInitializeProtocolVersion(line) {
   }
   return "2024-11-05";
 }
-function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
-  return new Promise((resolve44, reject) => {
+function connectWithRetry(socketPath, log2, maxRetries, retryDelayMs, connect2) {
+  return new Promise((resolve45, reject) => {
     const tryConnect = (attempt) => {
-      connect2(socketPath).then(resolve44).catch((err) => {
+      connect2(socketPath).then(resolve45).catch((err) => {
         if (attempt >= maxRetries) {
           reject(err);
           return;
         }
-        log(`connect attempt ${attempt + 1} failed, retrying in ${retryDelayMs}ms: ${String(err)}`);
+        log2(`connect attempt ${attempt + 1} failed, retrying in ${retryDelayMs}ms: ${String(err)}`);
         setTimeout(() => tryConnect(attempt + 1), retryDelayMs);
       });
     };
@@ -13851,13 +14021,13 @@ async function resolveBridgeSessionBinding(params, env2 = process.env, options =
     ...bridgeOptions
   });
 }
-async function stopDaemonsForStaleBinding(stale, env2, log, ideTypeOverride) {
+async function stopDaemonsForStaleBinding(stale, env2, log2, ideTypeOverride) {
   const ideType = resolveBindingIdeType(env2, ideTypeOverride);
   let processes;
   try {
     processes = await defaultListDaemonProcesses();
   } catch (err) {
-    log(`could not list daemon processes while replacing stale binding: ${String(err)}`);
+    log2(`could not list daemon processes while replacing stale binding: ${String(err)}`);
     return;
   }
   for (const proc of processes) {
@@ -13866,11 +14036,11 @@ async function stopDaemonsForStaleBinding(stale, env2, log, ideTypeOverride) {
     if (!matchesByBinding && !matchesByProject) continue;
     try {
       process.kill(proc.pid, "SIGTERM");
-      log(
+      log2(
         `stopped stale daemon pid=${proc.pid} binding=${stale.repositoryBindingId} project=${stale.projectId}`
       );
     } catch (err) {
-      log(`failed to stop stale daemon pid=${proc.pid}: ${String(err)}`);
+      log2(`failed to stop stale daemon pid=${proc.pid}: ${String(err)}`);
     }
   }
 }
@@ -13937,14 +14107,14 @@ async function runBridgeProxy(options) {
   ensureBaseDir();
   const stdin = options.stdin ?? process.stdin;
   const stdout = options.stdout ?? process.stdout;
-  const log = options.log ?? defaultLog;
+  const log2 = options.log ?? defaultLog;
   const lineReader = options.lineReader ?? new StdioLineReader(stdin);
   const router = new BridgeDaemonRouter({ ...options, stdout, lineReader });
   try {
     while (true) {
       const line = await lineReader.readLine();
       if (line === null) {
-        log("stdin EOF; closing daemon socket");
+        log2("stdin EOF; closing daemon socket");
         break;
       }
       const trimmed = line.trim();
@@ -13958,7 +14128,7 @@ async function runBridgeProxy(options) {
         throw new Error(`[memoraone-mcp] Invalid JSON-RPC on stdin: ${String(err)}`);
       }
       if (message.method === "initialize") {
-        log("resolve binding from initialize request before daemon connect");
+        log2("resolve binding from initialize request before daemon connect");
         const params = message.params ?? {};
         const sessionKind = await router.ensureDaemonForInitialize(params);
         if (sessionKind === "setup_required") {
@@ -13976,7 +14146,7 @@ async function runBridgeProxy(options) {
       if (!router.hasClientInitialize()) {
         const method = typeof message.method === "string" && message.method.trim() !== "" ? message.method : "(unknown)";
         if (message.id !== void 0 && message.id !== null) {
-          log(
+          log2(
             `pre-initialize request method=${method}; responding Method not found (legacy stdio probe)`
           );
           writePreInitializeJsonRpcError(
@@ -13985,7 +14155,7 @@ async function runBridgeProxy(options) {
             method
           );
         } else {
-          log(`ignoring pre-initialize notification method=${method}`);
+          log2(`ignoring pre-initialize notification method=${method}`);
         }
         continue;
       }
@@ -13995,12 +14165,12 @@ async function runBridgeProxy(options) {
     router.close();
   }
 }
-var net, readline4, import_node_child_process7, defaultLog, JSONRPC_METHOD_NOT_FOUND, SETUP_REQUIRED_FINISH_SETUP_TOOL, BridgeDaemonRouter;
+var net, readline4, import_node_child_process8, defaultLog, JSONRPC_METHOD_NOT_FOUND, SETUP_REQUIRED_FINISH_SETUP_TOOL, BridgeDaemonRouter;
 var init_bridgeProxy = __esm({
   "src/bridgeProxy.ts"() {
     net = __toESM(require("net"), 1);
     readline4 = __toESM(require("readline"), 1);
-    import_node_child_process7 = require("child_process");
+    import_node_child_process8 = require("child_process");
     init_bindingIdentity();
     init_bindingSidecar();
     init_bridgeClientRoots();
@@ -14041,13 +14211,13 @@ var init_bridgeProxy = __esm({
         this.maxRetries = options.maxRetries ?? 5;
         this.retryDelayMs = options.retryDelayMs ?? 200;
         this.lineReader = options.lineReader ?? null;
-        this.connectImpl = options.connect ?? ((socketPath) => new Promise((resolve44, reject) => {
-          const socket = net.connect(socketPath, () => resolve44(socket));
+        this.connectImpl = options.connect ?? ((socketPath) => new Promise((resolve45, reject) => {
+          const socket = net.connect(socketPath, () => resolve45(socket));
           socket.on("error", reject);
         }));
         this.spawnDaemonImpl = options.spawnDaemon ?? (async (binding) => {
           const ideType = this.activeIdeType;
-          const child = (0, import_node_child_process7.spawn)(
+          const child = (0, import_node_child_process8.spawn)(
             process.execPath,
             buildDaemonSpawnArgs(this.cliPath, binding.repositoryBindingId, this.env, ideType),
             {
@@ -14258,7 +14428,7 @@ var init_bridgeProxy = __esm({
       }
       waitForDaemonJsonRpcResponse(id, timeoutMs = 3e4) {
         const key = this.waiterKey(id);
-        return new Promise((resolve44, reject) => {
+        return new Promise((resolve45, reject) => {
           const timer = setTimeout(() => {
             this.pendingDaemonResponseWaiters.delete(key);
             reject(
@@ -14267,7 +14437,7 @@ var init_bridgeProxy = __esm({
               )
             );
           }, timeoutMs);
-          this.pendingDaemonResponseWaiters.set(key, { resolve: resolve44, reject, timer });
+          this.pendingDaemonResponseWaiters.set(key, { resolve: resolve45, reject, timer });
         });
       }
       notifyDaemonResponseWaiters(line) {
@@ -14457,6 +14627,8 @@ if (args.includes("--help") || args.includes("-h")) {
        memoraone-mcp connect <code> [--api-url <url>] [--verbose]
        memoraone-mcp plugin-pair --workspace-root <path> --source <cursor|jetbrains> [--api-url <url>]
        memoraone-mcp runtime-identity --workspace-root <path>
+       memoraone-mcp ensure-gateway
+       memoraone-mcp --gateway
        memoraone-mcp [--daemon --binding-id <mrb_\u2026> [--ide ${IDE_TYPE_CLI_CHOICES}]]
        memoraone-mcp setup-ide-files [--all|--cursor|--vscode|--jetbrains|--claude-code|--windsurf|--opencode|--codex|--kiro|--kiro-cli|--cline|--cline-cli|--claude-desktop|--zed|--visual-studio|--copilot-cli|--auggie|--antigravity|--goose|--junie|--xcode|--copilot-jetbrains|--copilot-visual-studio] [--force] [--dry-run] [--no-gitignore] [--cleanup] [--dev] [--repair] [--workspace-root <path>] [--api-url <url>] [--verbose]
          Cursor API environment (with --cursor or --all): --local (node + built cli.cjs + local API) | --staging (npx + staging API)
@@ -14507,6 +14679,18 @@ if (args[0] === "cleanup") {
 `);
     process.exit(1);
   });
+} else if (args[0] === "ensure-gateway") {
+  Promise.resolve().then(() => (init_gatewayEnsure(), gatewayEnsure_exports)).then(({ cliEnsureGateway: cliEnsureGateway2 }) => cliEnsureGateway2(args.slice(1))).then((code) => process.exit(code)).catch((err) => {
+    process.stderr.write(`[memoraone-mcp] ensure-gateway fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
+} else if (args.includes("--gateway")) {
+  import("./gateway.cjs").then(({ runGateway }) => runGateway()).catch((err) => {
+    process.stderr.write(`[memoraone-mcp] gateway fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
 } else if (args.includes("--daemon")) {
   import("./daemon.cjs").then(({ runDaemon }) => runDaemon()).catch((err) => {
     process.stderr.write(`[memoraone-mcp] daemon fatal: ${String(err)}

package/dist/daemon.cjs

@@ -1609,7 +1609,10 @@ async function reconcileResolvedBindingWithDisk(cached, options = {}) {
     );
   }
   const workspaceRoot = path10.resolve(record.workspaceRoot);
-  const identity = await captureRootFilesystemIdentity(workspaceRoot);
+  const identity = await captureRootFilesystemIdentity(
+    workspaceRoot,
+    options.identityDeps
+  );
   if (!identitiesMatch(record.filesystemIdentity, identity)) {
     throw new ReconnectRequiredError(
       "[memoraone-mcp] Workspace filesystem identity changed. Run: memoraone-mcp connect <code>"
@@ -1774,8 +1777,6 @@ function removeBindingSidecar(socketPath) {
 }
 
 // src/index.ts
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_types = require("@modelcontextprotocol/sdk/types.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/config.ts
@@ -1873,6 +1874,10 @@ var config2 = {
   heartbeatIntervalMs: Number.parseInt(parsed.data.MEMORAONE_HEARTBEAT_INTERVAL_MS ?? "1000", 10)
 };
 
+// src/memoraMcpServer.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+
 // src/initializeBinding.ts
 var path13 = __toESM(require("path"), 1);
 var import_node_url = require("url");
@@ -12280,7 +12285,7 @@ function inferIdeType(params, options = {}) {
   return void 0;
 }
 
-// src/index.ts
+// src/memoraMcpServer.ts
 var notInitializedResult = {
   content: [
     {
@@ -12365,7 +12370,7 @@ function registerToolWithWorklog(server, runtime, sessionContext, toolName, desc
   });
   server.tool(toolName, description, schema, wrapped);
 }
-async function main(opts = {}) {
+function createMemoraMcpServer(opts = {}) {
   let bindingReadyResolve = null;
   let bindingReadyReject = null;
   const bindingReady = new Promise((resolve42, reject) => {
@@ -12398,7 +12403,10 @@ async function main(opts = {}) {
           "[memoraone-mcp][init-debug] Workspace resolution strategy: daemonBindingHint (bridge pre-resolved, reconciled from disk)"
         );
       }
-      const reconciled = await reconcileResolvedBindingWithDisk(opts.daemonBindingHint);
+      const reconciled = await reconcileResolvedBindingWithDisk(
+        opts.daemonBindingHint,
+        opts.bindingResolveOptions ?? {}
+      );
       runtime.bindingCacheRefreshed = reconciled.cacheRefreshed;
       if (reconciled.cacheRefreshed) {
         console.error(
@@ -12851,11 +12859,35 @@ async function main(opts = {}) {
   if (devMode) {
     console.error("[memoraone-mcp] Starting MCP server with", registeredToolNames.length, "tools");
   }
-  const transport = opts.transport ?? new import_stdio.StdioServerTransport();
+  return {
+    server,
+    runtime,
+    sessionContext,
+    sessionLabel,
+    bindingReady,
+    getWorkspaceRoot: () => workspaceRoot
+  };
+}
+
+// src/index.ts
+async function main(opts = {}) {
+  const {
+    transport: customTransport,
+    sessionSocket,
+    ...serverOpts
+  } = opts;
+  const {
+    server,
+    runtime,
+    sessionLabel,
+    bindingReady
+  } = createMemoraMcpServer(serverOpts);
+  const devMode = Boolean(config2.devMode);
+  const transport = customTransport ?? new import_stdio.StdioServerTransport();
   await server.connect(transport);
   const activeClient = await bindingReady;
   let ownedHeartbeat = null;
-  const daemonSession = Boolean(opts.sessionSocket);
+  const daemonSession = Boolean(sessionSocket);
   if (activeClient) {
     if (config2.heartbeatEnabled && daemonSession) {
       console.error(
@@ -12902,9 +12934,9 @@ async function main(opts = {}) {
   if (devMode) {
     console.error("[memoraone-mcp] MCP server ready");
   }
-  if (opts.sessionSocket) {
+  if (sessionSocket) {
     await new Promise((resolve42) => {
-      opts.sessionSocket.once("close", () => {
+      sessionSocket.once("close", () => {
         shutdown("session closed", false);
         resolve42();
       });