@memoraone/mcp 0.1.52 → 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.52",
+      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();
@@ -13815,15 +13985,26 @@ function extractJsonRpcId(line) {
     return void 0;
   }
 }
-function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
-  return new Promise((resolve44, reject) => {
+function extractInitializeProtocolVersion(line) {
+  try {
+    const message = JSON.parse(line.trim());
+    const version2 = message.params?.protocolVersion;
+    if (typeof version2 === "string" && version2.trim() !== "") {
+      return version2;
+    }
+  } catch {
+  }
+  return "2024-11-05";
+}
+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);
       });
     };
@@ -13840,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) {
@@ -13855,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)}`);
     }
   }
 }
@@ -13926,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();
@@ -13947,17 +14128,25 @@ 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 ?? {};
-        await router.ensureDaemonForInitialize(params);
+        const sessionKind = await router.ensureDaemonForInitialize(params);
+        if (sessionKind === "setup_required") {
+          router.completeSetupRequiredInitialize(trimmed);
+          continue;
+        }
         await router.forwardInitializeToDaemon(trimmed);
         await router.replayDeferredClientMessages();
         continue;
       }
+      if (router.isSetupRequiredSession()) {
+        router.handleSetupRequiredClientLine(trimmed);
+        continue;
+      }
       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(
@@ -13966,7 +14155,7 @@ async function runBridgeProxy(options) {
             method
           );
         } else {
-          log(`ignoring pre-initialize notification method=${method}`);
+          log2(`ignoring pre-initialize notification method=${method}`);
         }
         continue;
       }
@@ -13976,12 +14165,12 @@ async function runBridgeProxy(options) {
     router.close();
   }
 }
-var net, readline4, import_node_child_process7, defaultLog, JSONRPC_METHOD_NOT_FOUND, 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();
@@ -13996,6 +14185,11 @@ var init_bridgeProxy = __esm({
 `);
     };
     JSONRPC_METHOD_NOT_FOUND = -32601;
+    SETUP_REQUIRED_FINISH_SETUP_TOOL = {
+      name: "memora_finish_setup",
+      description: "Start MemoraOne Cursor plugin pairing for this workspace so the user can finish setup. Returns an authorization URL and request metadata; does not open a browser. Use when this plugin-managed session is unbound (setup required).",
+      inputSchema: { type: "object", properties: {} }
+    };
     BridgeDaemonRouter = class {
       constructor(options) {
         this.activeSocket = null;
@@ -14006,6 +14200,8 @@ var init_bridgeProxy = __esm({
         this.pendingDeferredClientLines = [];
         this.handshakeDeferredClientLines = [];
         this.clientInitializeSeen = false;
+        /** Unbound Cursor-plugin session: no daemon by design; handshake is local. */
+        this.setupRequiredSession = false;
         /** Waiters for daemon JSON-RPC responses (keyed by request id). */
         this.pendingDaemonResponseWaiters = /* @__PURE__ */ new Map();
         this.env = options.env ?? process.env;
@@ -14015,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),
             {
@@ -14056,6 +14252,9 @@ var init_bridgeProxy = __esm({
       hasClientInitialize() {
         return this.clientInitializeSeen;
       }
+      isSetupRequiredSession() {
+        return this.setupRequiredSession;
+      }
       async ensureDaemonForInitialize(params) {
         logInitializeDebug(
           this.log,
@@ -14115,14 +14314,22 @@ var init_bridgeProxy = __esm({
           log: this.log
         }) : await resolveBinding();
         if (isPluginStartupSetupRequired(binding)) {
-          return;
+          this.setupRequiredSession = true;
+          this.activeBinding = null;
+          this.detachSocketReader();
+          const previousSocket = this.activeSocket;
+          this.activeSocket = null;
+          previousSocket?.destroy();
+          this.log("setup_required: no active binding; initialize will complete locally");
+          return "setup_required";
         }
+        this.setupRequiredSession = false;
         const environmentLog = binding.environment !== void 0 ? ` environment=${binding.environment}` : "";
         this.log(
           `session binding binding=${binding.repositoryBindingId} project=${binding.projectId} workspace=${binding.workspaceRoot} source=${binding.bindingSource}${environmentLog}`
         );
         if (this.activeBinding && bindingsMatch(this.activeBinding, binding) && this.activeSocket) {
-          return;
+          return "connected";
         }
         if (this.activeBinding && !bindingsMatch(this.activeBinding, binding)) {
           this.log(
@@ -14137,11 +14344,71 @@ var init_bridgeProxy = __esm({
         this.activeBinding = binding;
         await this.connectActiveDaemon();
         this.log("bridge connected");
+        return "connected";
       }
       recordClientInitialize(line) {
         this.lastInitializeLine = line;
         this.clientInitializeSeen = true;
       }
+      /**
+       * Finish Setup session: answer initialize on the bridge. Does not connect,
+       * spawn, or forward to a daemon — there is no binding by design.
+       */
+      completeSetupRequiredInitialize(line) {
+        this.recordClientInitialize(line);
+        const initId = extractJsonRpcId(line);
+        if (initId !== void 0) {
+          this.stdout.write(
+            `${JSON.stringify({
+              jsonrpc: "2.0",
+              id: initId,
+              result: {
+                protocolVersion: extractInitializeProtocolVersion(line),
+                capabilities: { tools: { listChanged: true } },
+                serverInfo: { name: "memoraone-mcp", version: "1.0.0" }
+              }
+            })}
+`
+          );
+        }
+        this.log("setup_required: initialize completed locally");
+        const deferred = this.pendingDeferredClientLines.slice();
+        this.pendingDeferredClientLines = [];
+        this.handshakeDeferredClientLines = deferred.slice();
+        for (const deferredLine of deferred) {
+          this.handleSetupRequiredClientLine(deferredLine);
+        }
+      }
+      /** Local MCP replies for a setup_required session (no daemon socket). */
+      handleSetupRequiredClientLine(line) {
+        let message;
+        try {
+          message = JSON.parse(line.trim());
+        } catch {
+          return;
+        }
+        const method = typeof message.method === "string" ? message.method : "";
+        const id = message.id;
+        if (method === "tools/list" && (typeof id === "string" || typeof id === "number")) {
+          this.stdout.write(
+            `${JSON.stringify({
+              jsonrpc: "2.0",
+              id,
+              result: { tools: [SETUP_REQUIRED_FINISH_SETUP_TOOL] }
+            })}
+`
+          );
+          return;
+        }
+        if (id === void 0 || id === null) {
+          return;
+        }
+        writePreInitializeJsonRpcError(
+          this.stdout,
+          id,
+          method.trim() !== "" ? method : "(unknown)"
+        );
+      }
       /**
        * Forward initialize to the daemon and wait for its JSON-RPC response before
        * returning. Prevents pipelined tools/call (e.g. Claude Code lazy MCP connect)
@@ -14161,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(
@@ -14170,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) {
@@ -14241,6 +14508,7 @@ var init_bridgeProxy = __esm({
         this.pendingDeferredClientLines = [];
         this.handshakeDeferredClientLines = [];
         this.clientInitializeSeen = false;
+        this.setupRequiredSession = false;
         this.activeBinding = null;
         this.activeIdeType = void 0;
       }
@@ -14359,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)
@@ -14409,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)}