@memoraone/mcp 0.1.57 → 0.1.59

package/dist/cli.cjs

@@ -231,7 +231,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.57",
+      version: "0.1.59",
       type: "module",
       main: "dist/index.cjs",
       exports: {

package/dist/gateway.cjs

@@ -2233,6 +2233,21 @@ async function reconcileResolvedBindingWithDisk(cached, options = {}) {
   }
   return { binding: fresh, cacheRefreshed: true };
 }
+async function checkRuntimeBindingValidity(cached, options = {}) {
+  try {
+    const { binding: current } = await reconcileResolvedBindingWithDisk(cached, options);
+    if (current.status !== "connected") {
+      return { valid: false, reason: `binding status is ${current.status}` };
+    }
+    if (!bindingRelevantValuesMatch(cached, current)) {
+      return { valid: false, reason: "binding metadata changed" };
+    }
+    return { valid: true };
+  } catch (err) {
+    const reason = err instanceof Error && err.message.trim() ? err.message : String(err);
+    return { valid: false, reason };
+  }
+}
 function encodeResolvedBinding(binding) {
   const payload = {
     repositoryBindingId: binding.repositoryBindingId,
@@ -11739,12 +11754,330 @@ var path50 = __toESM(require("path"), 1);
 var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
 var import_types2 = require("@modelcontextprotocol/sdk/types.js");
 
+// src/heartbeat.ts
+var crypto4 = __toESM(require("crypto"), 1);
+var fs37 = __toESM(require("fs"), 1);
+var path48 = __toESM(require("path"), 1);
+
+// src/localState/mcpSessionId.ts
+var import_node_crypto29 = require("crypto");
+var MCS_PREFIX = "mcs_";
+function generateMcpSessionId(random = () => (0, import_node_crypto29.randomBytes)(32)) {
+  const bytes = random();
+  if (bytes.length !== 32) {
+    throw new Error("[memoraone-mcp] mcp session id requires exactly 32 random bytes");
+  }
+  return `${MCS_PREFIX}${bytes.toString("base64url")}`;
+}
+
+// src/heartbeat.ts
+function fingerprintAccessToken(accessToken) {
+  return crypto4.createHash("sha256").update(accessToken).digest("hex").slice(0, 12);
+}
+function isHeartbeatDebugEnabled() {
+  const value = String(process.env.MEMORAONE_DEBUG_HEARTBEAT ?? "").trim().toLowerCase();
+  return ["1", "true", "yes", "on"].includes(value);
+}
+var LOCAL_MCP_HEARTBEAT_INTERVAL_MS = 1e3;
+function resolveHeartbeatIntervalMs() {
+  return LOCAL_MCP_HEARTBEAT_INTERVAL_MS;
+}
+function redactSensitiveText(text2) {
+  return text2.replace(/mcs_[A-Za-z0-9_-]+/g, "mcs_[redacted]").replace(/mia_[A-Za-z0-9_-]+/g, "mia_[redacted]").replace(/mir_[A-Za-z0-9_-]+/g, "mir_[redacted]").replace(/mcc_[A-Za-z0-9_-]+/g, "mcc_[redacted]").replace(/Bearer\s+\S+/gi, "Bearer [redacted]");
+}
+function resolvePackageVersion() {
+  const fromEnv = process.env.npm_package_version?.trim();
+  if (fromEnv) return fromEnv;
+  const moduleDir = typeof __dirname !== "undefined" ? __dirname : void 0;
+  const candidates = [
+    ...moduleDir ? [path48.join(moduleDir, "..", "package.json"), path48.join(moduleDir, "package.json")] : [],
+    path48.join(process.cwd(), "package.json"),
+    path48.join(process.cwd(), "packages", "mcp", "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const pkg = JSON.parse(fs37.readFileSync(candidate, "utf8"));
+      if (typeof pkg.version === "string" && pkg.version.trim()) {
+        return pkg.version.trim();
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function parseActiveFlag(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const active = payload.active;
+  if (typeof active === "boolean") return active;
+  return null;
+}
+async function announceIdeSession(client, ctx) {
+  const body = {
+    session_id: ctx.sessionId,
+    ide_type: ctx.ideType
+  };
+  if (ctx.packageVersion) {
+    body.package_version = ctx.packageVersion;
+  }
+  let lastErr;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const raw = await client.post("/v1/local-mcp/session/announce", body, { log: false });
+      const data = raw ?? {};
+      if (data.ok !== true || typeof data.active !== "boolean" || typeof data.ide_type !== "string") {
+        throw new Error("[memoraone-mcp] Invalid session announce response");
+      }
+      return {
+        ok: true,
+        active: data.active,
+        ideType: data.ide_type,
+        announcedAt: typeof data.announced_at === "string" ? data.announced_at : ""
+      };
+    } catch (err) {
+      lastErr = err;
+      if (err instanceof MemoraOneHttpError && (err.status === 404 || err.status === 405)) {
+        throw new Error(
+          "[memoraone-mcp] Session announce endpoint is not supported by this API (POST /v1/local-mcp/session/announce)"
+        );
+      }
+      const msg = String(err);
+      const transient = /fetch failed|ECONNRESET|ETIMEDOUT|ENOTFOUND|network|socket/i.test(msg) && !(err instanceof MemoraOneHttpError && err.status >= 400 && err.status < 500);
+      if (!transient || attempt === 1) {
+        break;
+      }
+    }
+  }
+  const safe = redactSensitiveText(String(lastErr));
+  throw new Error(`[memoraone-mcp] Session announce failed: ${safe}`);
+}
+async function sendProjectHeartbeat(client, ctx) {
+  try {
+    const pid = ctx.projectId?.trim();
+    if (isHeartbeatDebugEnabled()) {
+      process.stderr.write(
+        `[memoraone-mcp][diag] heartbeat projectId=${pid ?? "unknown"} binding=${ctx.repositoryBindingId} credentialSource=${ctx.credentialSource ?? "keyring"} accessTokenFingerprint=${ctx.accessTokenFingerprint ?? "unknown"} ideType=${ctx.ideType ?? "unknown"}
+`
+      );
+    }
+    if (!pid) {
+      throw new Error("[memoraone-mcp] Cannot send heartbeat without an active project binding");
+    }
+    const body = {};
+    if (ctx.ideType) body.ide_type = ctx.ideType;
+    if (ctx.sessionId) body.session_id = ctx.sessionId;
+    const raw = await client.post("/v1/local-mcp/heartbeat", body, { log: false });
+    return { active: parseActiveFlag(raw) };
+  } catch (err) {
+    process.stderr.write(
+      `[memoraone-mcp][info] heartbeat error (silent) ${redactSensitiveText(String(err))}
+`
+    );
+    return { active: null };
+  }
+}
+function createDaemonHeartbeat(opts) {
+  let interval = null;
+  let runGeneration = 0;
+  let client = null;
+  let announced = false;
+  let studioActive = null;
+  let starting = false;
+  let tickInFlight = false;
+  let bindingAuthorityEnded = false;
+  let waitingForIdeType = false;
+  const sessionId = opts.sessionId ?? generateMcpSessionId();
+  const packageVersion = opts.packageVersion ?? resolvePackageVersion();
+  const ctx = {
+    projectId: opts.binding.projectId,
+    repositoryBindingId: opts.binding.repositoryBindingId,
+    ideType: opts.ideType,
+    sessionId,
+    credentialSource: "keyring",
+    accessTokenFingerprint: null
+  };
+  const log4 = opts.onLog ?? ((msg) => {
+    process.stderr.write(`[memoraone-mcp][daemon-heartbeat] ${redactSensitiveText(msg)}
+`);
+  });
+  const validateBinding = opts.validateBinding ?? checkRuntimeBindingValidity;
+  const endBindingAuthority = (reason) => {
+    if (bindingAuthorityEnded) return;
+    bindingAuthorityEnded = true;
+    studioActive = false;
+    runGeneration += 1;
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    log4(`heartbeat authority ended: ${redactSensitiveText(reason)}`);
+  };
+  const bindingIsValid = async () => {
+    try {
+      const result = await validateBinding(opts.binding);
+      if (result.valid) return true;
+      endBindingAuthority("reason" in result ? result.reason : "binding is no longer valid");
+      return false;
+    } catch (err) {
+      endBindingAuthority(`binding validation failed: ${String(err)}`);
+      return false;
+    }
+  };
+  const ensureClient = async () => {
+    if (client) return client;
+    const creds = await readInstallationCredentials(opts.binding.repositoryBindingId);
+    if (!creds?.accessToken) {
+      log4("cannot start: no access token in keyring");
+      return null;
+    }
+    ctx.accessTokenFingerprint = fingerprintAccessToken(creds.accessToken);
+    client = opts.createClient?.(opts.binding) ?? new memoraClient_default(config2, {
+      repositoryBindingId: opts.binding.repositoryBindingId,
+      projectId: opts.binding.projectId
+    });
+    return client;
+  };
+  const ensureAnnounced = async (activeClient) => {
+    if (announced) return true;
+    if (!ctx.ideType) {
+      waitingForIdeType = true;
+      log4("waiting for ide type before session announce");
+      return false;
+    }
+    waitingForIdeType = false;
+    try {
+      const result = await announceIdeSession(activeClient, {
+        sessionId,
+        ideType: ctx.ideType,
+        packageVersion
+      });
+      announced = true;
+      studioActive = result.active;
+      log4(`session announced ideType=${ctx.ideType} active=${String(result.active)}`);
+      return true;
+    } catch (err) {
+      studioActive = false;
+      log4(`session announce failed: ${redactSensitiveText(String(err))}`);
+      return false;
+    }
+  };
+  const applyHeartbeatOutcome = (outcome) => {
+    if (outcome.active === null) return;
+    if (outcome.active === false && studioActive !== false) {
+      studioActive = false;
+      log4("session superseded (active=false); continuing to serve MCP without re-announce");
+      return;
+    }
+    if (outcome.active === true) {
+      studioActive = true;
+    }
+  };
+  const tick = async (generation) => {
+    if (!client || generation !== runGeneration || bindingAuthorityEnded || tickInFlight) return;
+    tickInFlight = true;
+    try {
+      if (!await bindingIsValid()) return;
+      if (generation !== runGeneration || !interval) return;
+      const outcome = await sendProjectHeartbeat(client, ctx);
+      if (generation !== runGeneration || !interval) return;
+      applyHeartbeatOutcome(outcome);
+    } finally {
+      tickInFlight = false;
+    }
+  };
+  const beginInterval = () => {
+    if (interval) return;
+    const intervalMs = resolveHeartbeatIntervalMs();
+    const generation = runGeneration;
+    log4(
+      `daemon owns heartbeat for binding=${opts.binding.repositoryBindingId} project=${opts.binding.projectId} ideType=${ctx.ideType ?? "unknown"} interval=${intervalMs}ms`
+    );
+    interval = setInterval(() => {
+      void tick(generation);
+    }, intervalMs);
+    interval.unref?.();
+    void tick(generation);
+  };
+  const start = async () => {
+    if (!config2.heartbeatEnabled) {
+      log4("disabled by config");
+      return;
+    }
+    if (interval) {
+      log4("already running (skipped duplicate start)");
+      return;
+    }
+    if (starting) {
+      log4("already starting (skipped duplicate start)");
+      return;
+    }
+    if (bindingAuthorityEnded) {
+      log4("binding authority already ended; heartbeat will not restart");
+      return;
+    }
+    starting = true;
+    try {
+      if (!await bindingIsValid()) return;
+      const activeClient = await ensureClient();
+      if (!activeClient) return;
+      const ok = await ensureAnnounced(activeClient);
+      if (!ok) {
+        return;
+      }
+      beginInterval();
+    } finally {
+      starting = false;
+      if (waitingForIdeType && !announced && !interval && ctx.ideType && config2.heartbeatEnabled) {
+        waitingForIdeType = false;
+        void start();
+      }
+    }
+  };
+  const stop = () => {
+    runGeneration += 1;
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    log4(`daemon released heartbeat for binding=${opts.binding.repositoryBindingId}`);
+  };
+  const isRunning = () => interval !== null;
+  const setIdeType = (ideType) => {
+    const previous = ctx.ideType;
+    if (previous === ideType) {
+      return;
+    }
+    ctx.ideType = ideType;
+    log4(`daemon heartbeat ideType updated to ${ideType}`);
+    if (!announced) {
+      void start();
+      return;
+    }
+    if (client && interval) {
+      void tick(runGeneration);
+    }
+  };
+  const getIdeType = () => ctx.ideType;
+  const getSessionId = () => sessionId;
+  const isStudioActive = () => studioActive;
+  const hasAnnounced = () => announced;
+  return {
+    start,
+    stop,
+    isRunning,
+    setIdeType,
+    getIdeType,
+    getSessionId,
+    isStudioActive,
+    hasAnnounced
+  };
+}
+
 // src/memoraMcpServer.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_types = require("@modelcontextprotocol/sdk/types.js");
 
 // src/pluginStartupBindingWait.ts
-var path48 = __toESM(require("path"), 1);
+var path49 = __toESM(require("path"), 1);
 var MEMORAONE_PLUGIN_ENV = "MEMORAONE_PLUGIN";
 var MEMORAONE_CURSOR_PLUGIN = "cursor";
 var PLUGIN_STARTUP_BINDING_WAIT_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -11805,7 +12138,7 @@ function collectPluginStartupBindingRoots(options) {
     if (raw === void 0 || raw === null || raw.trim() === "") {
       return;
     }
-    const resolved = path48.resolve(raw);
+    const resolved = path49.resolve(raw);
     if (seen.has(resolved)) {
       return;
     }
@@ -12098,11 +12431,11 @@ var LOCAL_MCP_TOOL_NAMES = [
 
 // src/tools/handlers/postEvent.ts
 var import_v415 = require("zod/v4");
-var crypto5 = __toESM(require("crypto"), 1);
+var crypto6 = __toESM(require("crypto"), 1);
 
 // src/runContext.ts
 var import_node_async_hooks = require("async_hooks");
-var crypto4 = __toESM(require("crypto"), 1);
+var crypto5 = __toESM(require("crypto"), 1);
 var sessionContextStorage = new import_node_async_hooks.AsyncLocalStorage();
 function createSessionRunContext(initial = {}) {
   return {
@@ -12149,7 +12482,7 @@ function resolveRunId(passed) {
   return getCurrentRunId();
 }
 function generateRunId() {
-  return crypto4.randomBytes(16).toString("hex");
+  return crypto5.randomBytes(16).toString("hex");
 }
 
 // src/tools/handlers/postEvent.ts
@@ -12189,7 +12522,7 @@ function buildPostEventContentFields(content) {
   return { message: JSON.stringify(content) };
 }
 async function handlePostEvent(client, args) {
-  const nonce = crypto5.randomBytes(8).toString("hex");
+  const nonce = crypto6.randomBytes(8).toString("hex");
   console.error(
     `[memoraone-mcp][debug] tool=memora_post_event toolCallId=unknown nonce=${nonce} stage=before_post`
   );
@@ -12899,19 +13232,6 @@ async function handleFinishSetup(options) {
   };
 }
 
-// src/heartbeat.ts
-var crypto6 = __toESM(require("crypto"), 1);
-var fs37 = __toESM(require("fs"), 1);
-var path49 = __toESM(require("path"), 1);
-
-// src/localState/mcpSessionId.ts
-var import_node_crypto29 = require("crypto");
-
-// src/heartbeat.ts
-function fingerprintAccessToken(accessToken) {
-  return crypto6.createHash("sha256").update(accessToken).digest("hex").slice(0, 12);
-}
-
 // src/ideType.ts
 var RELIABLE_CLIENT_INFO_NAMES = /* @__PURE__ */ new Map([
   // Existing
@@ -13653,6 +13973,66 @@ var log2 = (msg) => {
 `);
 };
 var sessionsById = /* @__PURE__ */ new Map();
+function isGatewayHeartbeatEnabled(env2) {
+  if (!config2.heartbeatEnabled) return false;
+  const raw = env2?.MEMORAONE_HEARTBEAT;
+  if (raw === void 0) return true;
+  const normalized = String(raw).trim().toLowerCase();
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  return true;
+}
+function stopSessionHeartbeat(session) {
+  if (!session.heartbeat) return;
+  session.heartbeat.stop();
+  session.heartbeat = null;
+}
+function releaseSession(session) {
+  session.closed = true;
+  stopSessionHeartbeat(session);
+}
+async function attachGatewayMcpSessionHeartbeat(session, handle, options = {}) {
+  if (session.heartbeatAttach) {
+    await session.heartbeatAttach;
+    return;
+  }
+  session.heartbeatAttach = (async () => {
+    let activeClient;
+    try {
+      activeClient = await handle.bindingReady;
+    } catch {
+      return;
+    }
+    if (session.closed) return;
+    if (!activeClient) return;
+    const boundClient = activeClient;
+    if (!handle.runtime.authoritativeBinding) return;
+    if (!isGatewayHeartbeatEnabled(options.env)) return;
+    if (session.heartbeat) return;
+    const heartbeat = createDaemonHeartbeat({
+      binding: handle.runtime.authoritativeBinding,
+      ideType: handle.runtime.ideType ?? config2.ideType,
+      createClient: () => boundClient,
+      validateBinding: (binding) => checkRuntimeBindingValidity(binding, { homeDir: options.homeDir }),
+      onLog: (msg) => {
+        log2(`[session-heartbeat] ${msg}`);
+      }
+    });
+    session.heartbeat = heartbeat;
+    if (session.closed) {
+      stopSessionHeartbeat(session);
+      return;
+    }
+    log2(
+      `${handle.sessionLabel} owns heartbeat for project ${handle.runtime.projectId}`
+    );
+    await heartbeat.start();
+    if (session.closed) {
+      stopSessionHeartbeat(session);
+    }
+  })();
+  await session.heartbeatAttach;
+}
 function sendJsonRpcHttpError(res, status, message) {
   if (res.headersSent) return;
   const body = JSON.stringify({
@@ -13744,6 +14124,7 @@ async function removeSession(sessionId) {
   const session = sessionsById.get(sessionId);
   if (!session) return;
   sessionsById.delete(sessionId);
+  releaseSession(session);
   try {
     await session.transport.close();
   } catch {
@@ -13779,7 +14160,11 @@ async function createSession(binding, canonicalUrl, options) {
       sessionsById.set(sessionId, sessionRef);
     },
     onsessionclosed: async (sessionId) => {
-      sessionsById.delete(sessionId);
+      const existing = sessionsById.get(sessionId);
+      if (existing) {
+        sessionsById.delete(sessionId);
+        releaseSession(existing);
+      }
     }
   });
   const handle = createMemoraMcpServer({
@@ -13789,15 +14174,24 @@ async function createSession(binding, canonicalUrl, options) {
     bindingResolveOptions: {
       homeDir: options.homeDir,
       identityDeps: options.identityDeps
+    },
+    onSessionIdeTypeKnown: (ideType) => {
+      sessionRef?.heartbeat?.setIdeType(ideType);
     }
   });
-  void handle.bindingReady.catch(() => {
-  });
   await handle.server.connect(transport);
   transport.onclose = () => {
     const sid = transport.sessionId;
     if (sid) {
-      sessionsById.delete(sid);
+      const existing = sessionsById.get(sid);
+      if (existing) {
+        sessionsById.delete(sid);
+        releaseSession(existing);
+      } else if (sessionRef && !sessionRef.closed) {
+        releaseSession(sessionRef);
+      }
+    } else if (sessionRef) {
+      releaseSession(sessionRef);
     }
   };
   sessionRef = {
@@ -13806,12 +14200,26 @@ async function createSession(binding, canonicalUrl, options) {
     canonicalUrl,
     binding,
     transport,
+    heartbeat: null,
+    heartbeatAttach: null,
+    closed: false,
     close: async () => {
       const sid = transport.sessionId;
-      if (sid) sessionsById.delete(sid);
-      await transport.close();
+      if (sid && sessionsById.get(sid) === sessionRef) {
+        await removeSession(sid);
+        return;
+      }
+      releaseSession(sessionRef);
+      try {
+        await transport.close();
+      } catch {
+      }
     }
   };
+  void attachGatewayMcpSessionHeartbeat(sessionRef, handle, options).catch(
+    () => {
+    }
+  );
   return sessionRef;
 }
 async function handleAuthenticatedGatewayMcpRequest(req, res, auth, options = {}) {
@@ -13914,6 +14322,9 @@ function sendPairingGate(res, body) {
   });
   res.end(body);
 }
+function canWriteGatewayResponse(res) {
+  return !res.writableEnded && !res.destroyed;
+}
 async function handleGatewayMcpAuthRequest(req, res, url, options = {}) {
   if (url.pathname !== GATEWAY_MCP_PATH) return false;
   const env2 = options.env ?? process.env;
@@ -13985,8 +14396,7 @@ async function handleGatewayMcpAuthRequest(req, res, url, options = {}) {
         return true;
       }
       const pairing = await coordinator.ensure(parsed2.workspaceRoot);
-      if (pairing.status === "pending") {
-        sendPairingGate(res, "Pairing pending");
+      if (!canWriteGatewayResponse(res)) {
         return true;
       }
       if (pairing.status === "failed") {
@@ -14026,6 +14436,9 @@ async function handleGatewayMcpAuthRequest(req, res, url, options = {}) {
     );
     return true;
   } catch {
+    if (!canWriteGatewayResponse(res)) {
+      return true;
+    }
     sendUnauthorized(res, env2, parsed2.workspaceRoot);
     return true;
   }
@@ -14078,13 +14491,19 @@ function createGatewayUnboundPairingCoordinator(options = {}) {
   const openUrl = options.openUrl ?? ((url) => openUrlInBrowser(url));
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS2;
   const apiUrl = (options.apiUrl ?? config2.apiUrl).replace(/\/+$/, "");
+  function settleLatch(key, entry, status) {
+    if (entry.status !== "pending") return;
+    entry.status = status;
+    entry.settle(status);
+    latches.delete(key);
+  }
   async function pollInBackground(key, session, entry) {
     for (; ; ) {
       let result;
       try {
         result = await session.poll();
       } catch {
-        entry.status = "failed";
+        settleLatch(key, entry, "failed");
         return;
       }
       if (result.status === "pending") {
@@ -14092,15 +14511,14 @@ function createGatewayUnboundPairingCoordinator(options = {}) {
         continue;
       }
       if (result.status === "ready") {
-        entry.status = "ready";
-        latches.delete(key);
+        settleLatch(key, entry, "ready");
         return;
       }
       if (result.status === "backend_failure" && result.operation === "poll") {
         await delay3(pollIntervalMs);
         continue;
       }
-      entry.status = "failed";
+      settleLatch(key, entry, "failed");
       return;
     }
   }
@@ -14122,18 +14540,16 @@ function createGatewayUnboundPairingCoordinator(options = {}) {
         try {
           await openUrl(authorizationUrl);
         } catch {
-          entry.status = "failed";
+          settleLatch(key, entry, "failed");
           return;
         }
       } else {
-        entry.status = "failed";
+        settleLatch(key, entry, "failed");
         return;
       }
-      setImmediate(() => {
-        void pollInBackground(key, session, entry);
-      });
+      void pollInBackground(key, session, entry);
     } catch {
-      entry.status = "failed";
+      settleLatch(key, entry, "failed");
     }
   }
   return {
@@ -14141,21 +14557,16 @@ function createGatewayUnboundPairingCoordinator(options = {}) {
       const key = path51.resolve(workspaceRoot);
       const existing = latches.get(key);
       if (existing) {
-        await existing.startPromise;
-        return { status: existing.status };
+        return { status: await existing.settled };
       }
-      let resolveStart;
-      const startPromise = new Promise((resolve47) => {
-        resolveStart = resolve47;
+      let settle;
+      const settled = new Promise((resolve47) => {
+        settle = resolve47;
       });
-      const entry = { status: "pending", startPromise };
+      const entry = { status: "pending", settled, settle };
       latches.set(key, entry);
-      try {
-        await startPairing(key, entry);
-      } finally {
-        resolveStart();
-      }
-      return { status: entry.status };
+      void startPairing(key, entry);
+      return { status: await entry.settled };
     }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memoraone/mcp",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "type": "module",
   "main": "dist/index.cjs",
   "exports": {