@memoraone/mcp 0.1.43 → 0.1.45

package/dist/cli.cjs

@@ -231,7 +231,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.43",
+      version: "0.1.45",
       type: "module",
       main: "dist/index.cjs",
       exports: {
@@ -497,8 +497,8 @@ async function acquireLocalLock(lockName, options = {}) {
   while (retries <= maxRetries) {
     try {
       try {
-        const stat4 = await fs3.stat(lockPath);
-        if (Date.now() - stat4.mtimeMs > maxLockAgeMs) {
+        const stat6 = await fs3.stat(lockPath);
+        if (Date.now() - stat6.mtimeMs > maxLockAgeMs) {
           await fs3.unlink(lockPath);
         }
       } catch (err) {
@@ -531,7 +531,7 @@ async function acquireLocalLock(lockName, options = {}) {
             `[memoraone-mcp] Failed to acquire lock ${lockName} after ${maxRetries} retries`
           );
         }
-        await new Promise((resolve40) => setTimeout(resolve40, retryDelayMs));
+        await new Promise((resolve43) => setTimeout(resolve43, retryDelayMs));
         continue;
       }
       throw err;
@@ -1092,9 +1092,9 @@ var init_memoraClient = __esm({
 });
 
 // src/localState/localConnectClient.ts
-async function requestJson(baseUrl, method, path44, options = {}) {
+async function requestJson(baseUrl, method, path47, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const url = `${baseUrl.replace(/\/+$/, "")}${path44.startsWith("/") ? path44 : `/${path44}`}`;
+  const url = `${baseUrl.replace(/\/+$/, "")}${path47.startsWith("/") ? path47 : `/${path47}`}`;
   const res = await fetchImpl(url, {
     method,
     headers: {
@@ -1117,6 +1117,85 @@ async function requestJson(baseUrl, method, path44, options = {}) {
   }
   return { status: res.status, statusText: res.statusText, ok: res.ok, json };
 }
+function requireString(data, key, responseName) {
+  const value = data[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`[memoraone-mcp] Invalid ${responseName} response`);
+  }
+  return value;
+}
+function normalizePluginPairingSource(source) {
+  if (source !== "cursor" && source !== "jetbrains") {
+    throw new Error("[memoraone-mcp] Pairing source must be cursor or jetbrains");
+  }
+  return source;
+}
+function pairingRepositoryName(workspaceRoot) {
+  const repositoryName = path8.basename(path8.resolve(workspaceRoot)).trim();
+  if (repositoryName.length === 0 || repositoryName.length > 256 || repositoryName.includes("/") || repositoryName.includes("\\")) {
+    throw new Error("[memoraone-mcp] Workspace basename is not safe pairing metadata");
+  }
+  return repositoryName;
+}
+async function createPluginPairingRequest(apiUrl, input2, options = {}) {
+  const body = {
+    repository_name: pairingRepositoryName(input2.workspaceRoot),
+    source: normalizePluginPairingSource(input2.source)
+  };
+  const res = await requestJson(apiUrl, "POST", "/v1/local-connect/pairing-requests", {
+    body,
+    fetchImpl: options.fetchImpl
+  });
+  const data = res.json ?? {};
+  return {
+    requestId: requireString(data, "request_id", "pairing create"),
+    pollingVerifier: requireString(data, "polling_verifier", "pairing create"),
+    authorizationUrl: requireString(data, "authorization_url", "pairing create"),
+    expiresAt: requireString(data, "expires_at", "pairing create")
+  };
+}
+async function pollPluginPairingRequest(apiUrl, request, options = {}) {
+  const requestId = encodeURIComponent(request.requestId);
+  const res = await requestJson(
+    apiUrl,
+    "POST",
+    `/v1/local-connect/pairing-requests/${requestId}/poll`,
+    {
+      body: { polling_verifier: request.pollingVerifier },
+      fetchImpl: options.fetchImpl
+    }
+  );
+  const data = res.json ?? {};
+  const expiresAt = requireString(data, "expires_at", "pairing poll");
+  if (data.status === "pending") {
+    return { status: "pending", expiresAt };
+  }
+  if (data.status === "ready") {
+    const code = requireString(data, "code", "pairing poll");
+    if (!code.startsWith("mcc_")) {
+      throw new Error("[memoraone-mcp] Invalid pairing poll response");
+    }
+    return { status: "ready", code, expiresAt };
+  }
+  throw new Error("[memoraone-mcp] Invalid pairing poll response");
+}
+async function cancelPluginPairingRequest(apiUrl, request, options = {}) {
+  const requestId = encodeURIComponent(request.requestId);
+  const res = await requestJson(
+    apiUrl,
+    "POST",
+    `/v1/local-connect/pairing-requests/${requestId}/cancel`,
+    {
+      body: { polling_verifier: request.pollingVerifier },
+      fetchImpl: options.fetchImpl
+    }
+  );
+  const data = res.json ?? {};
+  if (data.status !== "cancelled") {
+    throw new Error("[memoraone-mcp] Invalid pairing cancel response");
+  }
+  return { status: "cancelled" };
+}
 function assertSafeRedeemBody(body) {
   if ("canonical_root" in body) {
     throw new Error("[memoraone-mcp] redeem body must not include canonical_root");
@@ -1273,6 +1352,30 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
     legacyM1WarningPath
   };
 }
+async function lookupLocalBindingIdentity(workspaceRoot, options = {}) {
+  const resolved = path9.resolve(workspaceRoot);
+  const identity = await captureRootFilesystemIdentity(resolved, options.identityDeps);
+  const index = await loadPathIndex(options.homeDir);
+  const lookup = lookupPathIndex(index, resolved, identity);
+  if (lookup.kind !== "path") {
+    return { status: "unbound", workspaceRoot: resolved };
+  }
+  const record = await readBindingRecord(lookup.repositoryBindingId, options.homeDir);
+  if (!record) {
+    return { status: "unbound", workspaceRoot: resolved };
+  }
+  if (path9.resolve(record.workspaceRoot) !== resolved) {
+    return { status: "unbound", workspaceRoot: resolved };
+  }
+  if (!identityMatchesStored(record.filesystemIdentity, identity)) {
+    return { status: "unbound", workspaceRoot: resolved };
+  }
+  return {
+    status: "resolved",
+    workspaceRoot: resolved,
+    repositoryBindingId: record.repositoryBindingId
+  };
+}
 async function resolveLocalBinding(workspaceRoot, options = {}) {
   const resolved = path9.resolve(workspaceRoot);
   const { repositoryBindingId, legacyM1WarningPath } = await ensureRepositoryBindingForRoot(
@@ -3394,7 +3497,7 @@ function resolveApiUrl(env2) {
 var DEFAULT_API_URL, DEV_API_URL;
 var init_configUtils = __esm({
   "src/configUtils.ts"() {
-    DEFAULT_API_URL = "http://localhost:3001";
+    DEFAULT_API_URL = "https://api.memoraone.com";
     DEV_API_URL = "http://localhost:3001";
   }
 });
@@ -3549,11 +3652,11 @@ var init_repoFingerprint = __esm({
     };
     resolveGitDir = (gitPath) => {
       try {
-        const stat4 = fs13.statSync(gitPath);
-        if (stat4.isDirectory()) {
+        const stat6 = fs13.statSync(gitPath);
+        if (stat6.isDirectory()) {
           return gitPath;
         }
-        if (stat4.isFile()) {
+        if (stat6.isFile()) {
           const content = fs13.readFileSync(gitPath, "utf8");
           const match = content.match(/^gitdir:\s*(.+)$/m);
           if (match) {
@@ -3644,8 +3747,8 @@ function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
 }
 async function isZeroByteConfigFile(filePath) {
   if (!await pathExists3(filePath)) return false;
-  const stat4 = await fs14.stat(filePath);
-  return stat4.size === 0;
+  const stat6 = await fs14.stat(filePath);
+  return stat6.size === 0;
 }
 function stripDebugEnvVars(env2) {
   const next = {};
@@ -3847,7 +3950,7 @@ function formatOptionalJetBrainsHandshakeUnavailableDetail(detail) {
 async function verifyJetBrainsMcpHandshake(options) {
   const timeoutMs = options.timeoutMs ?? 15e3;
   const { server } = options;
-  return new Promise((resolve40) => {
+  return new Promise((resolve43) => {
     let settled = false;
     const finish = (ok, detail, optionalUnavailable) => {
       if (settled) return;
@@ -3857,7 +3960,7 @@ async function verifyJetBrainsMcpHandshake(options) {
         child.kill();
       } catch {
       }
-      resolve40({ ok, detail, optionalUnavailable });
+      resolve43({ ok, detail, optionalUnavailable });
     };
     const child = (0, import_node_child_process4.spawn)(server.command, [...server.args], {
       env: { ...process.env, ...server.env },
@@ -9528,6 +9631,14 @@ async function findRepoRoot(startDir) {
 function stripLeadingLineComments18(text) {
   return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
+function memoraUsagePolicy() {
+  return `- For every user question, check whether MemoraOne can provide relevant context before answering. If it can, use MemoraOne first.
+- Do not silently substitute IDE session history, local files, git history, or model memory when MemoraOne can provide relevant context.
+- Use **\`memora_status\`** for repository/project connection identity.
+- Use **\`memora_ask_with_memory\`** for previous questions/answers, conversation/history, decisions, facts, preferences, project context, and questions like "what did I/you say, ask, decide, or do before?"
+- Skip MemoraOne only when the question is clearly unrelated.
+- After the interaction: if anything meaningful happened\u2014question, answer, decision, discovery, action, correction, failure, or change\u2014record it back to MemoraOne so the next agent knows about it, especially if MemoraOne was not used before answering. Use **\`memora_post_event\`** and **\`memora_log_change_summary\`** according to their intended semantics; do not write trivial noise.`;
+}
 function cursorRuleBody() {
   return `${MANAGED_MARKER}
 
@@ -9537,7 +9648,7 @@ This repository uses **MemoraOne** via the MCP server named **memoraone** (repo-
 
 ### Tools
 
-- Before answering questions about **prior decisions**, **remembered facts**, **identity or personal recall**, **preferences**, **repo history**, or **what to do next**, call **\`memora_ask_with_memory\`** so replies stay aligned with MemoraOne memory.
+${memoraUsagePolicy()}
 - Use **\`memora_post_event\`** for durable project decisions, wiring, migrations, fixes, and meaningful product behavior changes. Prefer kind \`note\`, \`content.title\`, \`content.body\` (one concise, fact-promotable statement), and metadata \`source\` (e.g. \`cursor\`), \`purpose\`: \`dev-log\`, \`schema\`: \`v1\`.
 - Use **\`memora_log_change_summary\`** for concise code or feature deltas after implementation.
 
@@ -9555,7 +9666,7 @@ This repo is set up to use **MemoraOne** through MCP where your editor exposes i
 
 ## Behavior
 
-- For questions about **earlier decisions**, **stored facts**, **personal or identity recall**, **preferences**, **project history**, or **recommended next steps**, use MemoraOne memory tools (e.g. **\`memora_ask_with_memory\`**) when available before answering.
+${memoraUsagePolicy()}
 - Use **\`memora_post_event\`** for durable project decisions, wiring, migrations, fixes, and meaningful product behavior changes. Prefer kind \`note\`, \`content.title\`, \`content.body\` (one concise, fact-promotable statement), and metadata \`source\` (e.g. your agent name), \`purpose\`: \`dev-log\`, \`schema\`: \`v1\`.
 - Use **\`memora_log_change_summary\`** for concise code or feature deltas after implementation.
 
@@ -10317,6 +10428,7 @@ async function runSetupIdeFiles(o) {
   }
   const cursorContent = `---
 description: MemoraOne MCP \u2014 IDE agent instructions
+alwaysApply: true
 ---
 
 ` + cursorRuleBody();
@@ -12618,6 +12730,548 @@ var init_connectCommand = __esm({
   }
 });
 
+// src/pluginPairing.ts
+function backendErrorCode(error) {
+  if (!(error instanceof MemoraOneHttpError) || !error.body || typeof error.body !== "object") {
+    return void 0;
+  }
+  const code = error.body.error;
+  return typeof code === "string" ? code : void 0;
+}
+function mapPairingError(error) {
+  const code = backendErrorCode(error);
+  if (code === "pairing_rejected") return "rejected";
+  if (code === "pairing_cancelled") return "cancelled";
+  if (code === "pairing_consumed") return "consumed";
+  if (code === "pairing_expired") return "expired";
+  if (code === "invalid_pairing_verifier" || code === "pairing_not_found" || code === "bad_request") {
+    return "invalid";
+  }
+  if (error instanceof MemoraOneHttpError && error.status === 410) return "expired";
+  if (error instanceof MemoraOneHttpError && (error.status === 400 || error.status === 401)) {
+    return "invalid";
+  }
+  return "backend_failure";
+}
+async function beginPluginRepositoryPairing(options) {
+  const workspaceRoot = path44.resolve(options.workspaceRoot);
+  const apiUrl = (options.apiUrl ?? config2.apiUrl).replace(/\/+$/, "");
+  if (options.source !== "cursor" && options.source !== "jetbrains") {
+    throw new PluginPairingStartError("invalid");
+  }
+  try {
+    pairingRepositoryName(workspaceRoot);
+  } catch {
+    throw new PluginPairingStartError("invalid");
+  }
+  let request;
+  try {
+    request = await createPluginPairingRequest(
+      apiUrl,
+      { workspaceRoot, source: options.source },
+      { fetchImpl: options.fetchImpl }
+    );
+  } catch (error) {
+    const status = mapPairingError(error);
+    throw new PluginPairingStartError(status === "invalid" ? "invalid" : "backend_failure");
+  }
+  return new PluginRepositoryPairingSession(
+    request,
+    workspaceRoot,
+    options.source,
+    apiUrl,
+    options.fetchImpl,
+    options.connectOptions
+  );
+}
+var path44, PluginPairingStartError, PluginRepositoryPairingSession;
+var init_pluginPairing = __esm({
+  "src/pluginPairing.ts"() {
+    path44 = __toESM(require("path"), 1);
+    init_memoraClient();
+    init_config();
+    init_connectCommand();
+    init_localConnectClient();
+    PluginPairingStartError = class extends Error {
+      constructor(status) {
+        super(
+          status === "invalid" ? "[memoraone-mcp] Invalid plugin pairing request" : "[memoraone-mcp] Plugin pairing request could not be created"
+        );
+        this.status = status;
+        this.name = "PluginPairingStartError";
+      }
+    };
+    PluginRepositoryPairingSession = class {
+      constructor(request, workspaceRoot, source, apiUrl, fetchImpl, connectOptions = {}) {
+        this.workspaceRoot = workspaceRoot;
+        this.source = source;
+        this.apiUrl = apiUrl;
+        this.fetchImpl = fetchImpl;
+        this.connectOptions = connectOptions;
+        this.request = request;
+      }
+      /** Opaque, short-lived request metadata. Cleared when the session becomes terminal. */
+      get requestId() {
+        return this.request?.requestId;
+      }
+      get authorizationUrl() {
+        return this.request?.authorizationUrl;
+      }
+      get expiresAt() {
+        return this.request?.expiresAt;
+      }
+      finish(status) {
+        this.terminalStatus = status;
+        this.request = void 0;
+      }
+      async poll() {
+        if (!this.request) {
+          return {
+            status: this.terminalStatus === "cancelled" ? "cancelled" : "consumed",
+            operation: "poll"
+          };
+        }
+        let polled;
+        try {
+          polled = await pollPluginPairingRequest(this.apiUrl, this.request, {
+            fetchImpl: this.fetchImpl
+          });
+        } catch (error) {
+          const status = mapPairingError(error);
+          if (status !== "backend_failure") this.finish(status);
+          return { status, operation: "poll" };
+        }
+        if (polled.status === "pending") {
+          this.request.expiresAt = polled.expiresAt;
+          return polled;
+        }
+        try {
+          const connected = await runConnectCommand({
+            ...this.connectOptions,
+            code: polled.code,
+            cwd: this.workspaceRoot,
+            apiUrl: this.apiUrl,
+            ideType: this.source,
+            fetchImpl: this.connectOptions.fetchImpl ?? this.fetchImpl,
+            // The marketplace plugin is the authoritative IDE launch source.
+            configureIdes: false
+          });
+          if (connected.exitCode !== 0) {
+            this.finish("backend_failure");
+            return { status: "backend_failure", operation: "connect" };
+          }
+          this.finish("consumed");
+          return {
+            status: "ready",
+            repositoryBindingId: connected.repositoryBindingId
+          };
+        } catch {
+          this.finish("backend_failure");
+          return { status: "backend_failure", operation: "connect" };
+        }
+      }
+      async cancel() {
+        if (!this.request) {
+          const status = this.terminalStatus === "cancelled" ? "cancelled" : "consumed";
+          return status === "cancelled" ? { status } : { status, operation: "cancel" };
+        }
+        try {
+          await cancelPluginPairingRequest(this.apiUrl, this.request, {
+            fetchImpl: this.fetchImpl
+          });
+          this.finish("cancelled");
+          return { status: "cancelled" };
+        } catch (error) {
+          const status = mapPairingError(error);
+          if (status !== "backend_failure") this.finish(status);
+          return status === "cancelled" ? { status } : { status, operation: "cancel" };
+        }
+      }
+    };
+  }
+});
+
+// src/pluginPairCommand.ts
+var pluginPairCommand_exports = {};
+__export(pluginPairCommand_exports, {
+  DEFAULT_PLUGIN_PAIR_POLL_INTERVAL_MS: () => DEFAULT_PLUGIN_PAIR_POLL_INTERVAL_MS,
+  PLUGIN_PAIR_USAGE: () => PLUGIN_PAIR_USAGE,
+  cliPluginPair: () => cliPluginPair,
+  parsePluginPairArgv: () => parsePluginPairArgv
+});
+function isPluginPairingSource(value) {
+  return value === "cursor" || value === "jetbrains";
+}
+function parsePluginPairArgv(argv) {
+  let workspaceRoot;
+  let source;
+  let apiUrl;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--workspace-root") {
+      const value = argv[++i];
+      if (!value || value.startsWith("-")) return { error: PLUGIN_PAIR_USAGE };
+      workspaceRoot = value;
+      continue;
+    }
+    if (a.startsWith("--workspace-root=")) {
+      const value = a.slice("--workspace-root=".length);
+      if (!value) return { error: PLUGIN_PAIR_USAGE };
+      workspaceRoot = value;
+      continue;
+    }
+    if (a === "--source") {
+      const value = argv[++i];
+      if (!value || value.startsWith("-")) return { error: PLUGIN_PAIR_USAGE };
+      source = value;
+      continue;
+    }
+    if (a.startsWith("--source=")) {
+      const value = a.slice("--source=".length);
+      if (!value) return { error: PLUGIN_PAIR_USAGE };
+      source = value;
+      continue;
+    }
+    if (a === "--api-url") {
+      const value = argv[++i];
+      if (!value || value.startsWith("-")) return { error: PLUGIN_PAIR_USAGE };
+      apiUrl = value;
+      continue;
+    }
+    if (a.startsWith("--api-url=")) {
+      const value = a.slice("--api-url=".length);
+      if (!value) return { error: PLUGIN_PAIR_USAGE };
+      apiUrl = value;
+      continue;
+    }
+    if (a.startsWith("-")) {
+      return { error: `Unknown plugin-pair option: ${a}` };
+    }
+    return { error: PLUGIN_PAIR_USAGE };
+  }
+  return { workspaceRoot, source, apiUrl };
+}
+function writeEvent(event, stdoutWrite) {
+  const line = `${JSON.stringify(event)}
+`;
+  if (SECRET_OUTPUT_RE.test(line)) {
+    stdoutWrite(`${JSON.stringify({ event: "fatal", message: "Plugin pairing failed" })}
+`);
+    return;
+  }
+  stdoutWrite(line);
+}
+function delay(ms, signal) {
+  if (ms <= 0 || signal?.aborted) return Promise.resolve();
+  return new Promise((resolve43) => {
+    const timer = setTimeout(finish, ms);
+    const onAbort = () => finish();
+    function finish() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve43();
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function resolveWorkspaceRoot(workspaceRoot) {
+  const resolved = path45.resolve(workspaceRoot);
+  try {
+    const st = await fs38.stat(resolved);
+    if (!st.isDirectory()) {
+      return { error: "workspace-root must be a directory" };
+    }
+  } catch {
+    return { error: "workspace-root does not exist" };
+  }
+  return resolved;
+}
+function isRetryablePollFailure(result) {
+  return result.status === "backend_failure" && result.operation === "poll";
+}
+function terminalEventFromPoll(result) {
+  if (result.status === "pending" || result.status === "ready") return void 0;
+  if (result.operation) {
+    return { event: result.status, operation: result.operation };
+  }
+  return { event: result.status };
+}
+async function runPluginPairSession(session, options) {
+  const { workspaceRoot, source, pollIntervalMs, signal, stdoutWrite } = options;
+  const requestId = session.requestId;
+  const authorizationUrl = session.authorizationUrl;
+  const expiresAt = session.expiresAt;
+  if (!requestId || !authorizationUrl || !expiresAt) {
+    writeEvent({ event: "fatal", message: "Plugin pairing failed" }, stdoutWrite);
+    return 1;
+  }
+  writeEvent(
+    {
+      event: "started",
+      requestId,
+      authorizationUrl,
+      expiresAt,
+      workspaceRoot,
+      source
+    },
+    stdoutWrite
+  );
+  const cancelAndExit = async () => {
+    const cancelled = await session.cancel();
+    if (cancelled.status === "cancelled") {
+      writeEvent({ event: "cancelled" }, stdoutWrite);
+    } else {
+      writeEvent(
+        { event: cancelled.status, operation: cancelled.operation },
+        stdoutWrite
+      );
+    }
+    return 1;
+  };
+  while (!signal?.aborted) {
+    const result = await session.poll();
+    if (signal?.aborted) {
+      if (result.status === "ready") {
+        writeEvent(
+          {
+            event: "ready",
+            repositoryBindingId: result.repositoryBindingId,
+            workspaceRoot,
+            source,
+            status: "connected"
+          },
+          stdoutWrite
+        );
+        return 0;
+      }
+      return cancelAndExit();
+    }
+    if (result.status === "pending") {
+      writeEvent({ event: "pending", expiresAt: result.expiresAt }, stdoutWrite);
+      await delay(pollIntervalMs, signal);
+      continue;
+    }
+    if (result.status === "ready") {
+      writeEvent(
+        {
+          event: "ready",
+          repositoryBindingId: result.repositoryBindingId,
+          workspaceRoot,
+          source,
+          status: "connected"
+        },
+        stdoutWrite
+      );
+      return 0;
+    }
+    if (isRetryablePollFailure(result)) {
+      await delay(pollIntervalMs, signal);
+      continue;
+    }
+    const terminal = terminalEventFromPoll(result);
+    if (terminal) {
+      writeEvent(terminal, stdoutWrite);
+      return 1;
+    }
+    writeEvent({ event: "fatal", message: "Plugin pairing failed" }, stdoutWrite);
+    return 1;
+  }
+  return cancelAndExit();
+}
+async function cliPluginPair(argv, options = {}) {
+  const stdoutWrite = options.stdoutWrite ?? ((chunk) => process.stdout.write(chunk));
+  const parsed2 = parsePluginPairArgv(argv);
+  if (parsed2.error) {
+    writeEvent({ event: "fatal", message: parsed2.error }, stdoutWrite);
+    return 1;
+  }
+  if (!parsed2.workspaceRoot || !parsed2.source) {
+    writeEvent({ event: "fatal", message: PLUGIN_PAIR_USAGE }, stdoutWrite);
+    return 1;
+  }
+  if (!isPluginPairingSource(parsed2.source)) {
+    writeEvent({ event: "invalid" }, stdoutWrite);
+    return 1;
+  }
+  const workspaceRootOrError = await resolveWorkspaceRoot(parsed2.workspaceRoot);
+  if (typeof workspaceRootOrError !== "string") {
+    writeEvent({ event: "fatal", message: workspaceRootOrError.error }, stdoutWrite);
+    return 1;
+  }
+  const workspaceRoot = workspaceRootOrError;
+  const source = parsed2.source;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_PLUGIN_PAIR_POLL_INTERVAL_MS;
+  const beginPairing = options.beginPairing ?? beginPluginRepositoryPairing;
+  try {
+    const binding = await resolveAuthoritativeBinding(workspaceRoot);
+    if (binding.status === "connected") {
+      return 0;
+    }
+  } catch (error) {
+    if (!(error instanceof ReconnectRequiredError)) {
+      throw error;
+    }
+  }
+  const abortController = new AbortController();
+  const signal = options.signal ?? abortController.signal;
+  const onStop = () => abortController.abort();
+  const installSignalHandlers = options.installSignalHandlers === true;
+  if (installSignalHandlers) {
+    process.on("SIGINT", onStop);
+    process.on("SIGTERM", onStop);
+  }
+  try {
+    let session;
+    try {
+      session = await beginPairing({
+        workspaceRoot,
+        source,
+        apiUrl: parsed2.apiUrl,
+        fetchImpl: options.fetchImpl,
+        connectOptions: options.connectOptions
+      });
+    } catch (error) {
+      if (error instanceof PluginPairingStartError) {
+        writeEvent({ event: error.status, operation: "start" }, stdoutWrite);
+        return 1;
+      }
+      writeEvent({ event: "fatal", message: "Plugin pairing failed" }, stdoutWrite);
+      return 1;
+    }
+    return await runPluginPairSession(session, {
+      workspaceRoot,
+      source,
+      pollIntervalMs,
+      signal,
+      stdoutWrite
+    });
+  } finally {
+    if (installSignalHandlers) {
+      process.off("SIGINT", onStop);
+      process.off("SIGTERM", onStop);
+    }
+  }
+}
+var fs38, path45, PLUGIN_PAIR_USAGE, DEFAULT_PLUGIN_PAIR_POLL_INTERVAL_MS, SECRET_OUTPUT_RE;
+var init_pluginPairCommand = __esm({
+  "src/pluginPairCommand.ts"() {
+    fs38 = __toESM(require("fs/promises"), 1);
+    path45 = __toESM(require("path"), 1);
+    init_pluginPairing();
+    init_projectBinding();
+    init_tokenRefreshCoordinator();
+    PLUGIN_PAIR_USAGE = "Usage: memoraone-mcp plugin-pair --workspace-root <path> --source <cursor|jetbrains> [--api-url <url>]";
+    DEFAULT_PLUGIN_PAIR_POLL_INTERVAL_MS = 1e3;
+    SECRET_OUTPUT_RE = /\b(mcc_|mpv_|mia_|mir_|polling_verifier|pollingVerifier|access_token|refresh_token|api[_-]?key)\b/i;
+  }
+});
+
+// src/runtimeIdentityCommand.ts
+var runtimeIdentityCommand_exports = {};
+__export(runtimeIdentityCommand_exports, {
+  RUNTIME_IDENTITY_USAGE: () => RUNTIME_IDENTITY_USAGE,
+  cliRuntimeIdentity: () => cliRuntimeIdentity,
+  parseRuntimeIdentityArgv: () => parseRuntimeIdentityArgv
+});
+function parseRuntimeIdentityArgv(argv) {
+  let workspaceRoot;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--workspace-root") {
+      const value = argv[++i];
+      if (!value || value.startsWith("-")) return { error: RUNTIME_IDENTITY_USAGE };
+      workspaceRoot = value;
+      continue;
+    }
+    if (a.startsWith("--workspace-root=")) {
+      const value = a.slice("--workspace-root=".length);
+      if (!value) return { error: RUNTIME_IDENTITY_USAGE };
+      workspaceRoot = value;
+      continue;
+    }
+    if (a.startsWith("-")) {
+      return { error: `Unknown runtime-identity option: ${a}` };
+    }
+    return { error: RUNTIME_IDENTITY_USAGE };
+  }
+  return { workspaceRoot };
+}
+function writeJson(payload, stdoutWrite) {
+  const line = `${JSON.stringify(payload)}
+`;
+  if (SECRET_OUTPUT_RE2.test(line)) {
+    stdoutWrite(`${JSON.stringify({ status: "error", error: "Runtime identity failed" })}
+`);
+    return;
+  }
+  stdoutWrite(line);
+}
+async function resolveWorkspaceRoot2(workspaceRoot) {
+  const resolved = path46.resolve(workspaceRoot);
+  try {
+    const st = await fs39.stat(resolved);
+    if (!st.isDirectory()) {
+      return { error: "workspace-root must be a directory", workspaceRoot: resolved };
+    }
+  } catch {
+    return { error: "workspace-root does not exist", workspaceRoot: resolved };
+  }
+  return { workspaceRoot: resolved };
+}
+async function cliRuntimeIdentity(argv, options = {}) {
+  const stdoutWrite = options.stdoutWrite ?? ((chunk) => process.stdout.write(chunk));
+  const parsed2 = parseRuntimeIdentityArgv(argv);
+  if (parsed2.error) {
+    writeJson({ status: "error", error: parsed2.error }, stdoutWrite);
+    return 1;
+  }
+  if (!parsed2.workspaceRoot) {
+    writeJson({ status: "error", error: RUNTIME_IDENTITY_USAGE }, stdoutWrite);
+    return 1;
+  }
+  const workspaceRootOrError = await resolveWorkspaceRoot2(parsed2.workspaceRoot);
+  if ("error" in workspaceRootOrError) {
+    writeJson(
+      {
+        status: "error",
+        error: workspaceRootOrError.error,
+        workspaceRoot: workspaceRootOrError.workspaceRoot
+      },
+      stdoutWrite
+    );
+    return 1;
+  }
+  const lookupIdentity = options.lookupIdentity ?? lookupLocalBindingIdentity;
+  try {
+    const result = await lookupIdentity(workspaceRootOrError.workspaceRoot, {
+      homeDir: options.homeDir,
+      identityDeps: options.identityDeps
+    });
+    writeJson(result, stdoutWrite);
+    return 0;
+  } catch {
+    writeJson(
+      {
+        status: "error",
+        error: "Runtime identity failed",
+        workspaceRoot: workspaceRootOrError.workspaceRoot
+      },
+      stdoutWrite
+    );
+    return 1;
+  }
+}
+var fs39, path46, RUNTIME_IDENTITY_USAGE, SECRET_OUTPUT_RE2;
+var init_runtimeIdentityCommand = __esm({
+  "src/runtimeIdentityCommand.ts"() {
+    fs39 = __toESM(require("fs/promises"), 1);
+    path46 = __toESM(require("path"), 1);
+    init_resolveLocalBinding();
+    RUNTIME_IDENTITY_USAGE = "Usage: memoraone-mcp runtime-identity --workspace-root <path>";
+    SECRET_OUTPUT_RE2 = /\b(mcc_|mpv_|mia_|mir_|polling_verifier|pollingVerifier|access_token|refresh_token|api[_-]?key|projectId|project_id)\b/i;
+  }
+});
+
 // src/bridgeClientRoots.ts
 function isInitializeDebugEnabled(env2 = process.env) {
   return TRUTHY.has(String(env2.MEMORAONE_DEBUG_INIT ?? "").trim().toLowerCase());
@@ -12758,8 +13412,8 @@ var init_bridgeClientRoots = __esm({
         if (this.closed) {
           return null;
         }
-        return new Promise((resolve40) => {
-          this.waiters.push(resolve40);
+        return new Promise((resolve43) => {
+          this.waiters.push(resolve43);
         });
       }
       /** Re-queue lines read during an intermediate protocol step (e.g. roots/list) for the main bridge loop. */
@@ -12986,9 +13640,9 @@ function extractJsonRpcId(line) {
   }
 }
 function connectWithRetry(socketPath, log, maxRetries, retryDelayMs, connect2) {
-  return new Promise((resolve40, reject) => {
+  return new Promise((resolve43, reject) => {
     const tryConnect = (attempt) => {
-      connect2(socketPath).then(resolve40).catch((err) => {
+      connect2(socketPath).then(resolve43).catch((err) => {
         if (attempt >= maxRetries) {
           reject(err);
           return;
@@ -13184,8 +13838,8 @@ 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((resolve40, reject) => {
-          const socket = net.connect(socketPath, () => resolve40(socket));
+        this.connectImpl = options.connect ?? ((socketPath) => new Promise((resolve43, reject) => {
+          const socket = net.connect(socketPath, () => resolve43(socket));
           socket.on("error", reject);
         }));
         this.spawnDaemonImpl = options.spawnDaemon ?? (async (binding) => {
@@ -13317,7 +13971,7 @@ var init_bridgeProxy = __esm({
       }
       waitForDaemonJsonRpcResponse(id, timeoutMs = 3e4) {
         const key = this.waiterKey(id);
-        return new Promise((resolve40, reject) => {
+        return new Promise((resolve43, reject) => {
           const timer = setTimeout(() => {
             this.pendingDaemonResponseWaiters.delete(key);
             reject(
@@ -13326,7 +13980,7 @@ var init_bridgeProxy = __esm({
               )
             );
           }, timeoutMs);
-          this.pendingDaemonResponseWaiters.set(key, { resolve: resolve40, reject, timer });
+          this.pendingDaemonResponseWaiters.set(key, { resolve: resolve43, reject, timer });
         });
       }
       notifyDaemonResponseWaiters(line) {
@@ -13513,6 +14167,8 @@ if (args.includes("--help") || args.includes("-h")) {
   console.log(
     `Usage: memoraone-mcp [--version] [--help]
        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 [--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)
@@ -13535,6 +14191,28 @@ if (args[0] === "cleanup") {
 `);
     process.exit(1);
   });
+} else if (args[0] === "plugin-pair") {
+  Promise.resolve().then(() => (init_pluginPairCommand(), pluginPairCommand_exports)).then(
+    ({ cliPluginPair: cliPluginPair2 }) => cliPluginPair2(args.slice(1), { installSignalHandlers: true })
+  ).then((code) => process.exit(code)).catch((err) => {
+    process.stdout.write(
+      `${JSON.stringify({ event: "fatal", message: "Plugin pairing failed" })}
+`
+    );
+    process.stderr.write(`[memoraone-mcp] plugin-pair fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
+} else if (args[0] === "runtime-identity") {
+  Promise.resolve().then(() => (init_runtimeIdentityCommand(), runtimeIdentityCommand_exports)).then(({ cliRuntimeIdentity: cliRuntimeIdentity2 }) => cliRuntimeIdentity2(args.slice(1))).then((code) => process.exit(code)).catch((err) => {
+    process.stdout.write(
+      `${JSON.stringify({ status: "error", error: "Runtime identity failed" })}
+`
+    );
+    process.stderr.write(`[memoraone-mcp] runtime-identity fatal: ${String(err)}
+`);
+    process.exit(1);
+  });
 } else if (args[0] === "setup-ide-files") {
   Promise.resolve().then(() => (init_setupIdeFiles(), setupIdeFiles_exports)).then(({ cliSetupIdeFiles: cliSetupIdeFiles2 }) => cliSetupIdeFiles2(args.slice(1))).then((code) => process.exit(code)).catch((err) => {
     process.stderr.write(`[memoraone-mcp] setup-ide-files fatal: ${String(err)}

package/dist/daemon.cjs

@@ -1528,7 +1528,7 @@ var dotenv = __toESM(require("dotenv"), 1);
 var import_v4 = require("zod/v4");
 
 // src/configUtils.ts
-var DEFAULT_API_URL = "http://localhost:3001";
+var DEFAULT_API_URL = "https://api.memoraone.com";
 var DEV_API_URL = "http://localhost:3001";
 function resolveApiUrl(env2) {
   const explicitUrl = env2.MEMORAONE_API_URL?.trim();
@@ -3437,7 +3437,7 @@ async function main(opts = {}) {
   registeredToolNames.push("memora_get_personal_context");
   server.tool(
     "memora_status",
-    "Return non-secret project binding metadata for this MCP session",
+    "Return non-secret project binding metadata for this MCP session. Use this for repository/project connection identity: which repository or project this session is bound to. Prefer this over guessing from local files, git remotes, or IDE context.",
     bindingStatusShape,
     async () => runWithSessionContext(sessionContext, async () => {
       if (!runtime.authoritativeBinding) return notInitializedResult;
@@ -3455,7 +3455,7 @@ async function main(opts = {}) {
     runtime,
     sessionContext,
     "memora_ask_with_memory",
-    "Answer using saved workspace knowledge and timeline. In user-visible replies, state facts directly; do not attribute answers to tools, storage, retrieval, or memory-style framing unless the user asks how you know.",
+    'Answer using saved workspace knowledge and timeline. Use this before answering previous questions/answers, conversation/history, decisions, facts, preferences, project context, or questions like "what did I/you say, ask, decide, or do before?". Do not silently substitute IDE session history, local files, git history, or model memory when MemoraOne can provide relevant context. Skip only when the question is clearly unrelated. In user-visible replies, state facts directly; do not attribute answers to tools, storage, retrieval, or memory-style framing unless the user asks how you know.',
     askWithMemoryShape,
     async (args) => {
       const result = await handleAskWithMemory(runtime.client, args);

package/dist/index.cjs

@@ -45,7 +45,7 @@ var dotenv = __toESM(require("dotenv"), 1);
 var import_v4 = require("zod/v4");
 
 // src/configUtils.ts
-var DEFAULT_API_URL = "http://localhost:3001";
+var DEFAULT_API_URL = "https://api.memoraone.com";
 var DEV_API_URL = "http://localhost:3001";
 function resolveApiUrl(env2) {
   const explicitUrl = env2.MEMORAONE_API_URL?.trim();
@@ -3363,7 +3363,7 @@ async function main(opts = {}) {
   registeredToolNames.push("memora_get_personal_context");
   server.tool(
     "memora_status",
-    "Return non-secret project binding metadata for this MCP session",
+    "Return non-secret project binding metadata for this MCP session. Use this for repository/project connection identity: which repository or project this session is bound to. Prefer this over guessing from local files, git remotes, or IDE context.",
     bindingStatusShape,
     async () => runWithSessionContext(sessionContext, async () => {
       if (!runtime.authoritativeBinding) return notInitializedResult;
@@ -3381,7 +3381,7 @@ async function main(opts = {}) {
     runtime,
     sessionContext,
     "memora_ask_with_memory",
-    "Answer using saved workspace knowledge and timeline. In user-visible replies, state facts directly; do not attribute answers to tools, storage, retrieval, or memory-style framing unless the user asks how you know.",
+    'Answer using saved workspace knowledge and timeline. Use this before answering previous questions/answers, conversation/history, decisions, facts, preferences, project context, or questions like "what did I/you say, ask, decide, or do before?". Do not silently substitute IDE session history, local files, git history, or model memory when MemoraOne can provide relevant context. Skip only when the question is clearly unrelated. In user-visible replies, state facts directly; do not attribute answers to tools, storage, retrieval, or memory-style framing unless the user asks how you know.',
     askWithMemoryShape,
     async (args) => {
       const result = await handleAskWithMemory(runtime.client, args);

package/dist/pluginPairing.cjs

@@ -745,7 +745,7 @@ var dotenv = __toESM(require("dotenv"), 1);
 var import_v4 = require("zod/v4");
 
 // src/configUtils.ts
-var DEFAULT_API_URL = "http://localhost:3001";
+var DEFAULT_API_URL = "https://api.memoraone.com";
 var DEV_API_URL = "http://localhost:3001";
 function resolveApiUrl(env2) {
   const explicitUrl = env2.MEMORAONE_API_URL?.trim();
@@ -7526,6 +7526,14 @@ async function findRepoRoot(startDir) {
 function stripLeadingLineComments18(text) {
   return text.split("\n").filter((line) => !/^\s*\/\//.test(line)).join("\n");
 }
+function memoraUsagePolicy() {
+  return `- For every user question, check whether MemoraOne can provide relevant context before answering. If it can, use MemoraOne first.
+- Do not silently substitute IDE session history, local files, git history, or model memory when MemoraOne can provide relevant context.
+- Use **\`memora_status\`** for repository/project connection identity.
+- Use **\`memora_ask_with_memory\`** for previous questions/answers, conversation/history, decisions, facts, preferences, project context, and questions like "what did I/you say, ask, decide, or do before?"
+- Skip MemoraOne only when the question is clearly unrelated.
+- After the interaction: if anything meaningful happened\u2014question, answer, decision, discovery, action, correction, failure, or change\u2014record it back to MemoraOne so the next agent knows about it, especially if MemoraOne was not used before answering. Use **\`memora_post_event\`** and **\`memora_log_change_summary\`** according to their intended semantics; do not write trivial noise.`;
+}
 function cursorRuleBody() {
   return `${MANAGED_MARKER}
 
@@ -7535,7 +7543,7 @@ This repository uses **MemoraOne** via the MCP server named **memoraone** (repo-
 
 ### Tools
 
-- Before answering questions about **prior decisions**, **remembered facts**, **identity or personal recall**, **preferences**, **repo history**, or **what to do next**, call **\`memora_ask_with_memory\`** so replies stay aligned with MemoraOne memory.
+${memoraUsagePolicy()}
 - Use **\`memora_post_event\`** for durable project decisions, wiring, migrations, fixes, and meaningful product behavior changes. Prefer kind \`note\`, \`content.title\`, \`content.body\` (one concise, fact-promotable statement), and metadata \`source\` (e.g. \`cursor\`), \`purpose\`: \`dev-log\`, \`schema\`: \`v1\`.
 - Use **\`memora_log_change_summary\`** for concise code or feature deltas after implementation.
 
@@ -7553,7 +7561,7 @@ This repo is set up to use **MemoraOne** through MCP where your editor exposes i
 
 ## Behavior
 
-- For questions about **earlier decisions**, **stored facts**, **personal or identity recall**, **preferences**, **project history**, or **recommended next steps**, use MemoraOne memory tools (e.g. **\`memora_ask_with_memory\`**) when available before answering.
+${memoraUsagePolicy()}
 - Use **\`memora_post_event\`** for durable project decisions, wiring, migrations, fixes, and meaningful product behavior changes. Prefer kind \`note\`, \`content.title\`, \`content.body\` (one concise, fact-promotable statement), and metadata \`source\` (e.g. your agent name), \`purpose\`: \`dev-log\`, \`schema\`: \`v1\`.
 - Use **\`memora_log_change_summary\`** for concise code or feature deltas after implementation.
 
@@ -7927,6 +7935,7 @@ async function runSetupIdeFiles(o) {
   }
   const cursorContent = `---
 description: MemoraOne MCP \u2014 IDE agent instructions
+alwaysApply: true
 ---
 
 ` + cursorRuleBody();

package/package.json

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