@memoraone/mcp 0.1.48 → 0.1.49

package/dist/pluginPairing.cjs

@@ -944,16 +944,14 @@ var config2 = {
 };
 
 // src/localState/connectCommand.ts
-var fs37 = __toESM(require("fs/promises"), 1);
+var fs35 = __toESM(require("fs/promises"), 1);
 var path43 = __toESM(require("path"), 1);
 var os14 = __toESM(require("os"), 1);
 
 // src/projectBinding.ts
-var fs8 = __toESM(require("fs/promises"), 1);
 var path11 = __toESM(require("path"), 1);
 
 // src/localState/resolveLocalBinding.ts
-var fs7 = __toESM(require("fs/promises"), 1);
 var path10 = __toESM(require("path"), 1);
 
 // src/localState/pathIndex.ts
@@ -1171,19 +1169,9 @@ function identityMatchesStored(stored, current) {
 }
 
 // src/localState/resolveLocalBinding.ts
-async function detectLegacyM1Warning(workspaceRoot) {
-  const candidate = path10.join(path10.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
-  try {
-    await fs7.access(candidate);
-    return candidate;
-  } catch {
-    return void 0;
-  }
-}
 async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   const resolved = path10.resolve(workspaceRoot);
   const identity = await captureRootFilesystemIdentity(resolved, options.identityDeps);
-  const legacyM1WarningPath = await detectLegacyM1Warning(resolved);
   const index = await loadPathIndex(options.homeDir);
   const lookup = lookupPathIndex(index, resolved, identity);
   if (lookup.kind === "path") {
@@ -1207,8 +1195,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
       return {
         repositoryBindingId: record.repositoryBindingId,
         identity,
-        created: false,
-        legacyM1WarningPath
+        created: false
       };
     }
   }
@@ -1232,8 +1219,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
         repositoryBindingId: record.repositoryBindingId,
         identity,
         created: false,
-        renamedFrom: lookup.previousPath,
-        legacyM1WarningPath
+        renamedFrom: lookup.previousPath
       };
     }
   }
@@ -1246,13 +1232,12 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   return {
     repositoryBindingId,
     identity,
-    created: true,
-    legacyM1WarningPath
+    created: true
   };
 }
 async function resolveLocalBinding(workspaceRoot, options = {}) {
   const resolved = path10.resolve(workspaceRoot);
-  const { repositoryBindingId, legacyM1WarningPath } = await ensureRepositoryBindingForRoot(
+  const { repositoryBindingId } = await ensureRepositoryBindingForRoot(
     resolved,
     { ...options, createIfMissing: false }
   );
@@ -1295,8 +1280,7 @@ async function resolveLocalBinding(workspaceRoot, options = {}) {
     installationPublicId: record.installationPublicId ?? creds.installationPublicId,
     environment: record.environment,
     bindingSource: "local-binding",
-    status: record.status,
-    legacyM1WarningPath
+    status: record.status
   };
 }
 
@@ -1318,23 +1302,9 @@ function toResolvedBinding(local) {
     installationPublicId: local.installationPublicId,
     environment: local.environment,
     bindingSource: "local-binding",
-    status: local.status,
-    legacyM1WarningPath: local.legacyM1WarningPath
+    status: local.status
   };
 }
-async function warnLegacyM1IfPresent(workspaceRoot) {
-  const candidate = path11.join(path11.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
-  try {
-    await fs8.access(candidate);
-    process.stderr.write(
-      `[memoraone-mcp] warning: ignoring legacy ${CANONICAL_M1_FILENAME} (not used for credentials or binding)
-`
-    );
-    return candidate;
-  } catch {
-    return void 0;
-  }
-}
 async function resolveAuthoritativeBinding(workspaceRoot, _options = {}) {
   const candidates = normalizeWorkspaceSearchRoots(workspaceRoot);
   if (candidates.length === 0) {
@@ -1344,7 +1314,6 @@ async function resolveAuthoritativeBinding(workspaceRoot, _options = {}) {
   }
   const bindings = [];
   for (const root of candidates) {
-    await warnLegacyM1IfPresent(root);
     try {
       const local = await resolveLocalBinding(root);
       bindings.push(toResolvedBinding(local));
@@ -1440,12 +1409,12 @@ function decodeResolvedBinding(value) {
 var path13 = __toESM(require("path"), 1);
 
 // src/resolveBuiltCliPath.ts
-var fs9 = __toESM(require("fs/promises"), 1);
+var fs7 = __toESM(require("fs/promises"), 1);
 var path12 = __toESM(require("path"), 1);
 var MONOREPO_CLI_REL = path12.join("packages", "mcp", "dist", "cli.cjs");
 async function pathExists(filePath) {
   try {
-    await fs9.access(filePath);
+    await fs7.access(filePath);
     return true;
   } catch {
     return false;
@@ -1612,7 +1581,7 @@ function formatIdeSetupRepairHint(workspaceRoot, mode) {
 }
 
 // src/repoFingerprint.ts
-var fs10 = __toESM(require("fs"), 1);
+var fs8 = __toESM(require("fs"), 1);
 var path14 = __toESM(require("path"), 1);
 var crypto2 = __toESM(require("crypto"), 1);
 var parseBooleanFlag3 = (value) => {
@@ -1643,12 +1612,12 @@ var sha256 = (value) => {
 };
 var resolveGitDir = (gitPath) => {
   try {
-    const stat4 = fs10.statSync(gitPath);
+    const stat4 = fs8.statSync(gitPath);
     if (stat4.isDirectory()) {
       return gitPath;
     }
     if (stat4.isFile()) {
-      const content = fs10.readFileSync(gitPath, "utf8");
+      const content = fs8.readFileSync(gitPath, "utf8");
       const match = content.match(/^gitdir:\s*(.+)$/m);
       if (match) {
         const gitDir = match[1].trim();
@@ -1664,7 +1633,7 @@ var findGitRoot = (start) => {
   let current = path14.resolve(start);
   while (true) {
     const gitPath = path14.join(current, ".git");
-    if (fs10.existsSync(gitPath)) {
+    if (fs8.existsSync(gitPath)) {
       const gitDir = resolveGitDir(gitPath);
       if (gitDir) {
         return { gitRoot: current, gitDir };
@@ -1681,7 +1650,7 @@ var findGitRoot = (start) => {
 var readOriginRemote = (gitDir) => {
   const configPath = path14.join(gitDir, "config");
   try {
-    const content = fs10.readFileSync(configPath, "utf8");
+    const content = fs8.readFileSync(configPath, "utf8");
     const lines = content.split(/\r?\n/);
     let inOrigin = false;
     for (const line of lines) {
@@ -1737,13 +1706,13 @@ function resolveRepoFingerprint(cwd2) {
 }
 
 // src/setupIdeFiles.ts
-var fs34 = __toESM(require("fs/promises"), 1);
+var fs32 = __toESM(require("fs/promises"), 1);
 var os13 = __toESM(require("os"), 1);
 var path40 = __toESM(require("path"), 1);
 var import_node_crypto25 = require("crypto");
 
 // src/cleanup.ts
-var fs13 = __toESM(require("fs/promises"), 1);
+var fs11 = __toESM(require("fs/promises"), 1);
 var path19 = __toESM(require("path"), 1);
 var readline = __toESM(require("readline/promises"), 1);
 var import_node_child_process3 = require("child_process");
@@ -1751,7 +1720,7 @@ var import_node_util3 = require("util");
 var import_node_process = require("process");
 
 // src/bindingSidecar.ts
-var fs11 = __toESM(require("fs"), 1);
+var fs9 = __toESM(require("fs"), 1);
 var path15 = __toESM(require("path"), 1);
 function bindingSidecarPath(socketPath) {
   if (socketPath.endsWith(".sock")) {
@@ -1784,7 +1753,7 @@ function parseSidecarRecord(raw) {
 }
 function readBindingSidecarRecord(socketPath) {
   try {
-    const raw = fs11.readFileSync(bindingSidecarPath(socketPath), "utf8");
+    const raw = fs9.readFileSync(bindingSidecarPath(socketPath), "utf8");
     return parseSidecarRecord(raw);
   } catch {
     return null;
@@ -1792,7 +1761,7 @@ function readBindingSidecarRecord(socketPath) {
 }
 
 // src/cursorGlobalMcpConfig.ts
-var fs12 = __toESM(require("fs/promises"), 1);
+var fs10 = __toESM(require("fs/promises"), 1);
 var os4 = __toESM(require("os"), 1);
 var path18 = __toESM(require("path"), 1);
 var import_node_child_process2 = require("child_process");
@@ -2075,7 +2044,7 @@ function buildMemoraoneCursorMcpServer(options) {
 }
 async function pathExists2(filePath) {
   try {
-    await fs12.access(filePath);
+    await fs10.access(filePath);
     return true;
   } catch {
     return false;
@@ -2126,7 +2095,7 @@ async function isWorkingNpx(npxPath) {
     if (!await pathExists2(npxPath)) return false;
     if (process.platform !== "win32") {
       try {
-        await fs12.access(npxPath, fs12.constants.X_OK);
+        await fs10.access(npxPath, fs10.constants.X_OK);
       } catch {
         return false;
       }
@@ -2239,7 +2208,7 @@ function getCursorRepoMcpConfigPath(repoRoot) {
 }
 async function readCursorMcpConfigObject(configPath) {
   try {
-    const raw = await fs12.readFile(configPath, "utf8");
+    const raw = await fs10.readFile(configPath, "utf8");
     return JSON.parse(stripLeadingLineComments(raw));
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
@@ -2257,17 +2226,17 @@ async function removeMemoraoneFromCursorGlobalConfig(options) {
     return { changed: true, backupPath: `${configPath}.backup-<timestamp>` };
   }
   const backupPath = `${configPath}.backup-${formatBackupTimestamp()}`;
-  await fs12.copyFile(configPath, backupPath);
+  await fs10.copyFile(configPath, backupPath);
   const mcpServersRaw = typeof parsed2.mcpServers === "object" && parsed2.mcpServers !== null && !Array.isArray(parsed2.mcpServers) ? parsed2.mcpServers : {};
   const { next: mcpServers } = stripMemoraoneOwnedFromServerMap(mcpServersRaw);
   const hasOtherServers = Object.keys(mcpServers).length > 0;
   if (!hasOtherServers) {
-    await fs12.unlink(configPath);
+    await fs10.unlink(configPath);
     return { changed: true, backupPath };
   }
   const next = { ...parsed2, mcpServers };
-  await fs12.mkdir(path18.dirname(configPath), { recursive: true });
-  await fs12.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  await fs10.mkdir(path18.dirname(configPath), { recursive: true });
+  await fs10.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
   return { changed: true, backupPath };
 }
 async function auditCursorMcpConfig(options) {
@@ -2462,7 +2431,7 @@ async function defaultListSocketPaths(projectId) {
   const baseDir = getMcpBaseDir();
   let entries;
   try {
-    entries = await fs13.readdir(baseDir);
+    entries = await fs11.readdir(baseDir);
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
     if (code === "ENOENT") {
@@ -2499,7 +2468,7 @@ async function defaultListSocketPathsForWorkspaceRoot(workspaceRoot) {
   const baseDir = getMcpBaseDir();
   let entries;
   try {
-    entries = await fs13.readdir(baseDir);
+    entries = await fs11.readdir(baseDir);
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
     if (code === "ENOENT") {
@@ -2550,9 +2519,9 @@ async function defaultKillProcess(pid, signal = "SIGTERM") {
   process.kill(pid, signal);
 }
 async function defaultRemoveSocket(socketPath) {
-  await fs13.unlink(socketPath);
+  await fs11.unlink(socketPath);
   try {
-    await fs13.unlink(bindingSidecarPath(socketPath));
+    await fs11.unlink(bindingSidecarPath(socketPath));
   } catch {
   }
 }
@@ -2891,7 +2860,7 @@ async function runCleanup(opts) {
 }
 
 // src/jetbrainsMcpConfig.ts
-var fs14 = __toESM(require("fs/promises"), 1);
+var fs12 = __toESM(require("fs/promises"), 1);
 var os5 = __toESM(require("os"), 1);
 var path20 = __toESM(require("path"), 1);
 var import_node_crypto5 = require("crypto");
@@ -2901,7 +2870,7 @@ function stripLeadingLineComments2(text) {
 }
 async function pathExists3(filePath) {
   try {
-    await fs14.access(filePath);
+    await fs12.access(filePath);
     return true;
   } catch {
     return false;
@@ -2928,7 +2897,7 @@ function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
 }
 async function isZeroByteConfigFile(filePath) {
   if (!await pathExists3(filePath)) return false;
-  const stat4 = await fs14.stat(filePath);
+  const stat4 = await fs12.stat(filePath);
   return stat4.size === 0;
 }
 function buildMemoraoneJetBrainsMcpServer(options) {
@@ -2960,17 +2929,17 @@ function mergeJetBrainsMcpConfigObject(existing, memoraone, ownership) {
 }
 async function writeJetBrainsMcpJsonAtomic(filePath, content) {
   const dir = path20.dirname(filePath);
-  await fs14.mkdir(dir, { recursive: true });
+  await fs12.mkdir(dir, { recursive: true });
   const tmpPath = path20.join(
     dir,
     `.${path20.basename(filePath)}.${process.pid}.${(0, import_node_crypto5.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs14.writeFile(tmpPath, content, "utf8");
-    await fs14.rename(tmpPath, filePath);
+    await fs12.writeFile(tmpPath, content, "utf8");
+    await fs12.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs14.unlink(tmpPath);
+      await fs12.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -2996,13 +2965,13 @@ function validateJetBrainsMcpConfig(parsed2, expected, serverName = CANONICAL_ME
   }
 }
 async function readJsonConfig(filePath) {
-  const raw = await fs14.readFile(filePath, "utf8");
+  const raw = await fs12.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments2(raw));
 }
 async function backupConfigFile(filePath) {
   const backupPath = `${filePath}.bak-${formatJetBrainsBackupTimestamp()}`;
-  await fs14.copyFile(filePath, backupPath);
+  await fs12.copyFile(filePath, backupPath);
   return backupPath;
 }
 async function repairZeroByteConfigFile(filePath, dryRun) {
@@ -3013,7 +2982,7 @@ async function repairZeroByteConfigFile(filePath, dryRun) {
     return { repaired: true, backupPath: `${filePath}.bak-<timestamp>` };
   }
   const backupPath = await backupConfigFile(filePath);
-  await fs14.unlink(filePath);
+  await fs12.unlink(filePath);
   return { repaired: true, backupPath };
 }
 function configHasMemoraone(parsed2) {
@@ -3044,12 +3013,12 @@ async function removeMemoraoneFromProjectConfig(options) {
   const { next: mcpServers } = stripMemoraoneOwnedFromServerMap(mcpServersRaw);
   const hasOtherServers = Object.keys(mcpServers).length > 0;
   if (!hasOtherServers) {
-    await fs14.unlink(configPath);
+    await fs12.unlink(configPath);
     return { changed: true, backupPath };
   }
   const next = { ...parsed2, mcpServers };
-  await fs14.mkdir(path20.dirname(configPath), { recursive: true });
-  await fs14.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  await fs12.mkdir(path20.dirname(configPath), { recursive: true });
+  await fs12.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
   return { changed: true, backupPath };
 }
 async function resolveLocalCliPathAsync() {
@@ -3274,7 +3243,7 @@ async function setupJetBrainsMcpConfig(options) {
     backupPath = await backupConfigFile(globalPath);
   }
   await writeJetBrainsMcpJsonAtomic(globalPath, body);
-  const verifyRaw = await fs14.readFile(globalPath, "utf8");
+  const verifyRaw = await fs12.readFile(globalPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments2(verifyRaw));
   validateJetBrainsMcpConfig(verifyParsed, memoraone, options.ownership ? memoraoneServerNameForRepositoryBinding(options.ownership.repositoryBindingId) : CANONICAL_MEMORAONE_MCP_SERVER_NAME);
   const outcome = existed ? "updated" : "created";
@@ -3295,7 +3264,7 @@ async function setupJetBrainsMcpConfig(options) {
 }
 
 // src/windsurfMcpConfig.ts
-var fs15 = __toESM(require("fs/promises"), 1);
+var fs13 = __toESM(require("fs/promises"), 1);
 var os6 = __toESM(require("os"), 1);
 var path21 = __toESM(require("path"), 1);
 var import_node_crypto6 = require("crypto");
@@ -3304,7 +3273,7 @@ function stripLeadingLineComments3(text) {
 }
 async function pathExists4(filePath) {
   try {
-    await fs15.access(filePath);
+    await fs13.access(filePath);
     return true;
   } catch {
     return false;
@@ -3364,17 +3333,17 @@ function stripMemoraoneFromWindsurfConfigObject(existing) {
 }
 async function writeWindsurfMcpJsonAtomic(filePath, content) {
   const dir = path21.dirname(filePath);
-  await fs15.mkdir(dir, { recursive: true });
+  await fs13.mkdir(dir, { recursive: true });
   const tmpPath = path21.join(
     dir,
     `.${path21.basename(filePath)}.${process.pid}.${(0, import_node_crypto6.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs15.writeFile(tmpPath, content, "utf8");
-    await fs15.rename(tmpPath, filePath);
+    await fs13.writeFile(tmpPath, content, "utf8");
+    await fs13.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs15.unlink(tmpPath);
+      await fs13.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -3400,13 +3369,13 @@ function validateWindsurfMcpConfig(parsed2, expected, serverName = CANONICAL_MEM
   }
 }
 async function readJsonConfig2(filePath) {
-  const raw = await fs15.readFile(filePath, "utf8");
+  const raw = await fs13.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments3(raw));
 }
 async function backupConfigFile2(filePath) {
   const backupPath = `${filePath}.bak-${formatWindsurfBackupTimestamp()}`;
-  await fs15.copyFile(filePath, backupPath);
+  await fs13.copyFile(filePath, backupPath);
   return backupPath;
 }
 function extractMemoraone(existing) {
@@ -3541,7 +3510,7 @@ async function setupWindsurfMcpConfig(options) {
   }
   if (!activeAlreadyCorrect) {
     await writeWindsurfMcpJsonAtomic(activePath, body);
-    const verifyRaw = await fs15.readFile(activePath, "utf8");
+    const verifyRaw = await fs13.readFile(activePath, "utf8");
     const verifyParsed = JSON.parse(stripLeadingLineComments3(verifyRaw));
     validateWindsurfMcpConfig(verifyParsed, memoraone, options.ownership ? memoraoneServerNameForRepositoryBinding(options.ownership.repositoryBindingId) : CANONICAL_MEMORAONE_MCP_SERVER_NAME);
   }
@@ -3581,7 +3550,7 @@ async function setupWindsurfMcpConfig(options) {
 }
 
 // src/opencodeMcpConfig.ts
-var fs16 = __toESM(require("fs/promises"), 1);
+var fs14 = __toESM(require("fs/promises"), 1);
 var path22 = __toESM(require("path"), 1);
 var import_node_crypto7 = require("crypto");
 var OPENCODE_CONFIG_SCHEMA_URL = "https://opencode.ai/config.json";
@@ -3605,7 +3574,7 @@ var OpenCodeJsoncOnlyError = class extends Error {
 };
 async function pathExists5(filePath) {
   try {
-    await fs16.access(filePath);
+    await fs14.access(filePath);
     return true;
   } catch {
     return false;
@@ -3657,17 +3626,17 @@ function mergeOpenCodeMcpConfigObject(existing, memoraone) {
 }
 async function writeOpenCodeMcpJsonAtomic(filePath, content) {
   const dir = path22.dirname(filePath);
-  await fs16.mkdir(dir, { recursive: true });
+  await fs14.mkdir(dir, { recursive: true });
   const tmpPath = path22.join(
     dir,
     `.${path22.basename(filePath)}.${process.pid}.${(0, import_node_crypto7.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs16.writeFile(tmpPath, content, "utf8");
-    await fs16.rename(tmpPath, filePath);
+    await fs14.writeFile(tmpPath, content, "utf8");
+    await fs14.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs16.unlink(tmpPath);
+      await fs14.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -3692,7 +3661,7 @@ function validateOpenCodeMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig3(filePath) {
-  const raw = await fs16.readFile(filePath, "utf8");
+  const raw = await fs14.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(raw);
 }
@@ -3777,7 +3746,7 @@ async function setupOpenCodeMcpConfig(options) {
     return { outcome: jsonExists ? "updated" : "created", memoraone };
   }
   await writeOpenCodeMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs16.readFile(projectPath, "utf8");
+  const verifyRaw = await fs14.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(verifyRaw);
   validateOpenCodeMcpConfig(verifyParsed, memoraone);
   return {
@@ -3787,7 +3756,7 @@ async function setupOpenCodeMcpConfig(options) {
 }
 
 // src/codexMcpConfig.ts
-var fs17 = __toESM(require("fs/promises"), 1);
+var fs15 = __toESM(require("fs/promises"), 1);
 var path23 = __toESM(require("path"), 1);
 var import_node_crypto8 = require("crypto");
 var import_smol_toml = require("smol-toml");
@@ -3804,7 +3773,7 @@ var CodexMcpTomlParseError = class extends Error {
 };
 async function pathExists6(filePath) {
   try {
-    await fs17.access(filePath);
+    await fs15.access(filePath);
     return true;
   } catch {
     return false;
@@ -4064,17 +4033,17 @@ function parseCodexTomlOrThrow(source, configPath) {
 }
 async function writeCodexTomlAtomic(filePath, content) {
   const dir = path23.dirname(filePath);
-  await fs17.mkdir(dir, { recursive: true });
+  await fs15.mkdir(dir, { recursive: true });
   const tmpPath = path23.join(
     dir,
     `.${path23.basename(filePath)}.${process.pid}.${(0, import_node_crypto8.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs17.writeFile(tmpPath, content, "utf8");
-    await fs17.rename(tmpPath, filePath);
+    await fs15.writeFile(tmpPath, content, "utf8");
+    await fs15.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs17.unlink(tmpPath);
+      await fs15.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -4135,7 +4104,7 @@ async function setupCodexMcpConfig(options) {
   const exists = await pathExists6(projectPath);
   let existingRaw = null;
   if (exists) {
-    existingRaw = await fs17.readFile(projectPath, "utf8");
+    existingRaw = await fs15.readFile(projectPath, "utf8");
     const parsed2 = parseCodexTomlOrThrow(existingRaw, projectPath);
     const current = extractMemoraoneFromCodexParsed(parsed2);
     if (memoraoneServerMatches4(current, memoraone)) {
@@ -4147,7 +4116,7 @@ async function setupCodexMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeCodexTomlAtomic(projectPath, next);
-  const verifyRaw = await fs17.readFile(projectPath, "utf8");
+  const verifyRaw = await fs15.readFile(projectPath, "utf8");
   const verifyParsed = parseCodexTomlOrThrow(verifyRaw, projectPath);
   validateCodexMcpConfig(verifyParsed, memoraone);
   return {
@@ -4157,7 +4126,7 @@ async function setupCodexMcpConfig(options) {
 }
 
 // src/kiroMcpConfig.ts
-var fs18 = __toESM(require("fs/promises"), 1);
+var fs16 = __toESM(require("fs/promises"), 1);
 var path24 = __toESM(require("path"), 1);
 var import_node_crypto9 = require("crypto");
 var KiroMcpJsonParseError = class extends Error {
@@ -4174,7 +4143,7 @@ function stripLeadingLineComments4(text) {
 }
 async function pathExists7(filePath) {
   try {
-    await fs18.access(filePath);
+    await fs16.access(filePath);
     return true;
   } catch {
     return false;
@@ -4213,17 +4182,17 @@ function mergeKiroMcpConfigObject(existing, memoraone) {
 }
 async function writeKiroMcpJsonAtomic(filePath, content) {
   const dir = path24.dirname(filePath);
-  await fs18.mkdir(dir, { recursive: true });
+  await fs16.mkdir(dir, { recursive: true });
   const tmpPath = path24.join(
     dir,
     `.${path24.basename(filePath)}.${process.pid}.${(0, import_node_crypto9.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs18.writeFile(tmpPath, content, "utf8");
-    await fs18.rename(tmpPath, filePath);
+    await fs16.writeFile(tmpPath, content, "utf8");
+    await fs16.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs18.unlink(tmpPath);
+      await fs16.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -4248,7 +4217,7 @@ function validateKiroMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig4(filePath) {
-  const raw = await fs18.readFile(filePath, "utf8");
+  const raw = await fs16.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments4(raw));
 }
@@ -4328,7 +4297,7 @@ async function setupKiroMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeKiroMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs18.readFile(projectPath, "utf8");
+  const verifyRaw = await fs16.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments4(verifyRaw));
   validateKiroMcpConfig(verifyParsed, memoraone);
   return {
@@ -4338,7 +4307,7 @@ async function setupKiroMcpConfig(options) {
 }
 
 // src/rooCodeMcpConfig.ts
-var fs19 = __toESM(require("fs/promises"), 1);
+var fs17 = __toESM(require("fs/promises"), 1);
 var path25 = __toESM(require("path"), 1);
 var import_node_crypto10 = require("crypto");
 var RooCodeMcpJsonParseError = class extends Error {
@@ -4355,7 +4324,7 @@ function stripLeadingLineComments5(text) {
 }
 async function pathExists8(filePath) {
   try {
-    await fs19.access(filePath);
+    await fs17.access(filePath);
     return true;
   } catch {
     return false;
@@ -4395,17 +4364,17 @@ function mergeRooCodeMcpConfigObject(existing, memoraone) {
 }
 async function writeRooCodeMcpJsonAtomic(filePath, content) {
   const dir = path25.dirname(filePath);
-  await fs19.mkdir(dir, { recursive: true });
+  await fs17.mkdir(dir, { recursive: true });
   const tmpPath = path25.join(
     dir,
     `.${path25.basename(filePath)}.${process.pid}.${(0, import_node_crypto10.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs19.writeFile(tmpPath, content, "utf8");
-    await fs19.rename(tmpPath, filePath);
+    await fs17.writeFile(tmpPath, content, "utf8");
+    await fs17.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs19.unlink(tmpPath);
+      await fs17.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -4430,7 +4399,7 @@ function validateRooCodeMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig5(filePath) {
-  const raw = await fs19.readFile(filePath, "utf8");
+  const raw = await fs17.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments5(raw));
 }
@@ -4510,7 +4479,7 @@ async function setupRooCodeMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeRooCodeMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs19.readFile(projectPath, "utf8");
+  const verifyRaw = await fs17.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments5(verifyRaw));
   validateRooCodeMcpConfig(verifyParsed, memoraone);
   return {
@@ -4520,7 +4489,7 @@ async function setupRooCodeMcpConfig(options) {
 }
 
 // src/clineCliMcpConfig.ts
-var fs20 = __toESM(require("fs/promises"), 1);
+var fs18 = __toESM(require("fs/promises"), 1);
 var os7 = __toESM(require("os"), 1);
 var path26 = __toESM(require("path"), 1);
 var import_node_crypto11 = require("crypto");
@@ -4539,7 +4508,7 @@ function stripLeadingLineComments6(text) {
 }
 async function pathExists9(filePath) {
   try {
-    await fs20.access(filePath);
+    await fs18.access(filePath);
     return true;
   } catch {
     return false;
@@ -4593,17 +4562,17 @@ function mergeClineCliMcpConfigObject(existing, memoraone, ownership) {
 }
 async function writeClineCliMcpJsonAtomic(filePath, content) {
   const dir = path26.dirname(filePath);
-  await fs20.mkdir(dir, { recursive: true });
+  await fs18.mkdir(dir, { recursive: true });
   const tmpPath = path26.join(
     dir,
     `.${path26.basename(filePath)}.${process.pid}.${(0, import_node_crypto11.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs20.writeFile(tmpPath, content, "utf8");
-    await fs20.rename(tmpPath, filePath);
+    await fs18.writeFile(tmpPath, content, "utf8");
+    await fs18.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs20.unlink(tmpPath);
+      await fs18.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -4629,7 +4598,7 @@ function validateClineCliMcpConfig(parsed2, expected, serverName = CANONICAL_MEM
   }
 }
 async function readJsonConfig6(filePath) {
-  const raw = await fs20.readFile(filePath, "utf8");
+  const raw = await fs18.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments6(raw));
 }
@@ -4750,7 +4719,7 @@ async function setupClineCliMcpConfig(options) {
   for (const prepared of [rootPrepared, settingsPrepared]) {
     if (prepared.alreadyCorrect) continue;
     await writeClineCliMcpJsonAtomic(prepared.filePath, prepared.body);
-    const verifyRaw = await fs20.readFile(prepared.filePath, "utf8");
+    const verifyRaw = await fs18.readFile(prepared.filePath, "utf8");
     const verifyParsed = JSON.parse(stripLeadingLineComments6(verifyRaw));
     validateClineCliMcpConfig(
       verifyParsed,
@@ -4770,7 +4739,7 @@ async function setupClineCliMcpConfig(options) {
 }
 
 // src/claudeDesktopMcpConfig.ts
-var fs21 = __toESM(require("fs/promises"), 1);
+var fs19 = __toESM(require("fs/promises"), 1);
 var os8 = __toESM(require("os"), 1);
 var path27 = __toESM(require("path"), 1);
 var import_node_crypto12 = require("crypto");
@@ -4788,7 +4757,7 @@ function stripLeadingLineComments7(text) {
 }
 async function pathExists10(filePath) {
   try {
-    await fs21.access(filePath);
+    await fs19.access(filePath);
     return true;
   } catch {
     return false;
@@ -4838,17 +4807,17 @@ function mergeClaudeDesktopMcpConfigObject(existing, memoraone, ownership) {
 }
 async function writeClaudeDesktopMcpJsonAtomic(filePath, content) {
   const dir = path27.dirname(filePath);
-  await fs21.mkdir(dir, { recursive: true });
+  await fs19.mkdir(dir, { recursive: true });
   const tmpPath = path27.join(
     dir,
     `.${path27.basename(filePath)}.${process.pid}.${(0, import_node_crypto12.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs21.writeFile(tmpPath, content, "utf8");
-    await fs21.rename(tmpPath, filePath);
+    await fs19.writeFile(tmpPath, content, "utf8");
+    await fs19.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs21.unlink(tmpPath);
+      await fs19.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -4874,13 +4843,13 @@ function validateClaudeDesktopMcpConfig(parsed2, expected, serverName = CANONICA
   }
 }
 async function readJsonConfig7(filePath) {
-  const raw = await fs21.readFile(filePath, "utf8");
+  const raw = await fs19.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments7(raw));
 }
 async function backupConfigFile3(filePath) {
   const backupPath = `${filePath}.bak-${formatClaudeDesktopBackupTimestamp()}`;
-  await fs21.copyFile(filePath, backupPath);
+  await fs19.copyFile(filePath, backupPath);
   return backupPath;
 }
 async function buildClaudeDesktopMemoraoneServer(options) {
@@ -4967,7 +4936,7 @@ async function setupClaudeDesktopMcpConfig(options) {
     backupPath = await backupConfigFile3(activePath);
   }
   await writeClaudeDesktopMcpJsonAtomic(activePath, body);
-  const verifyRaw = await fs21.readFile(activePath, "utf8");
+  const verifyRaw = await fs19.readFile(activePath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments7(verifyRaw));
   validateClaudeDesktopMcpConfig(verifyParsed, memoraone, options.ownership ? memoraoneServerNameForRepositoryBinding(options.ownership.repositoryBindingId) : CANONICAL_MEMORAONE_MCP_SERVER_NAME);
   return {
@@ -4979,7 +4948,7 @@ async function setupClaudeDesktopMcpConfig(options) {
 }
 
 // src/zedMcpConfig.ts
-var fs22 = __toESM(require("fs/promises"), 1);
+var fs20 = __toESM(require("fs/promises"), 1);
 var path28 = __toESM(require("path"), 1);
 var import_node_crypto13 = require("crypto");
 var ZedMcpJsonParseError = class extends Error {
@@ -4996,7 +4965,7 @@ function stripLeadingLineComments8(text) {
 }
 async function pathExists11(filePath) {
   try {
-    await fs22.access(filePath);
+    await fs20.access(filePath);
     return true;
   } catch {
     return false;
@@ -5039,17 +5008,17 @@ function mergeZedMcpConfigObject(existing, memoraone) {
 }
 async function writeZedMcpJsonAtomic(filePath, content) {
   const dir = path28.dirname(filePath);
-  await fs22.mkdir(dir, { recursive: true });
+  await fs20.mkdir(dir, { recursive: true });
   const tmpPath = path28.join(
     dir,
     `.${path28.basename(filePath)}.${process.pid}.${(0, import_node_crypto13.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs22.writeFile(tmpPath, content, "utf8");
-    await fs22.rename(tmpPath, filePath);
+    await fs20.writeFile(tmpPath, content, "utf8");
+    await fs20.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs22.unlink(tmpPath);
+      await fs20.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -5074,7 +5043,7 @@ function validateZedMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig8(filePath) {
-  const raw = await fs22.readFile(filePath, "utf8");
+  const raw = await fs20.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments8(raw));
 }
@@ -5154,7 +5123,7 @@ async function setupZedMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeZedMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs22.readFile(projectPath, "utf8");
+  const verifyRaw = await fs20.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments8(verifyRaw));
   validateZedMcpConfig(verifyParsed, memoraone);
   return {
@@ -5164,7 +5133,7 @@ async function setupZedMcpConfig(options) {
 }
 
 // src/visualStudioMcpConfig.ts
-var fs23 = __toESM(require("fs/promises"), 1);
+var fs21 = __toESM(require("fs/promises"), 1);
 var path29 = __toESM(require("path"), 1);
 var import_node_crypto14 = require("crypto");
 var VisualStudioMcpJsonParseError = class extends Error {
@@ -5181,7 +5150,7 @@ function stripLeadingLineComments9(text) {
 }
 async function pathExists12(filePath) {
   try {
-    await fs23.access(filePath);
+    await fs21.access(filePath);
     return true;
   } catch {
     return false;
@@ -5222,17 +5191,17 @@ function mergeVisualStudioMcpConfigObject(existing, memoraone) {
 }
 async function writeVisualStudioMcpJsonAtomic(filePath, content) {
   const dir = path29.dirname(filePath);
-  await fs23.mkdir(dir, { recursive: true });
+  await fs21.mkdir(dir, { recursive: true });
   const tmpPath = path29.join(
     dir,
     `.${path29.basename(filePath)}.${process.pid}.${(0, import_node_crypto14.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs23.writeFile(tmpPath, content, "utf8");
-    await fs23.rename(tmpPath, filePath);
+    await fs21.writeFile(tmpPath, content, "utf8");
+    await fs21.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs23.unlink(tmpPath);
+      await fs21.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -5257,7 +5226,7 @@ function validateVisualStudioMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig9(filePath) {
-  const raw = await fs23.readFile(filePath, "utf8");
+  const raw = await fs21.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments9(raw));
 }
@@ -5337,7 +5306,7 @@ async function setupVisualStudioMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeVisualStudioMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs23.readFile(projectPath, "utf8");
+  const verifyRaw = await fs21.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments9(verifyRaw));
   validateVisualStudioMcpConfig(verifyParsed, memoraone);
   return {
@@ -5347,7 +5316,7 @@ async function setupVisualStudioMcpConfig(options) {
 }
 
 // src/continueMcpConfig.ts
-var fs24 = __toESM(require("fs/promises"), 1);
+var fs22 = __toESM(require("fs/promises"), 1);
 var path30 = __toESM(require("path"), 1);
 var import_node_crypto15 = require("crypto");
 var import_yaml = require("yaml");
@@ -5362,7 +5331,7 @@ var ContinueMcpYamlParseError = class extends Error {
 };
 async function pathExists13(filePath) {
   try {
-    await fs24.access(filePath);
+    await fs22.access(filePath);
     return true;
   } catch {
     return false;
@@ -5429,17 +5398,17 @@ function mergeContinueMcpConfigObject(existing, memoraone) {
 }
 async function writeContinueMcpYamlAtomic(filePath, content) {
   const dir = path30.dirname(filePath);
-  await fs24.mkdir(dir, { recursive: true });
+  await fs22.mkdir(dir, { recursive: true });
   const tmpPath = path30.join(
     dir,
     `.${path30.basename(filePath)}.${process.pid}.${(0, import_node_crypto15.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs24.writeFile(tmpPath, content, "utf8");
-    await fs24.rename(tmpPath, filePath);
+    await fs22.writeFile(tmpPath, content, "utf8");
+    await fs22.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs24.unlink(tmpPath);
+      await fs22.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -5534,7 +5503,7 @@ async function setupContinueMcpConfig(options) {
   let existing = null;
   if (exists) {
     try {
-      const raw = await fs24.readFile(projectPath, "utf8");
+      const raw = await fs22.readFile(projectPath, "utf8");
       existing = parseContinueYaml(raw);
     } catch {
       throw new ContinueMcpYamlParseError(projectPath);
@@ -5559,7 +5528,7 @@ async function setupContinueMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeContinueMcpYamlAtomic(projectPath, body);
-  const verifyRaw = await fs24.readFile(projectPath, "utf8");
+  const verifyRaw = await fs22.readFile(projectPath, "utf8");
   let verifyParsed;
   try {
     verifyParsed = (0, import_yaml.parse)(verifyRaw);
@@ -5575,7 +5544,7 @@ async function setupContinueMcpConfig(options) {
 
 // src/clineMcpConfig.ts
 var import_node_crypto16 = require("crypto");
-var fs25 = __toESM(require("fs/promises"), 1);
+var fs23 = __toESM(require("fs/promises"), 1);
 var path31 = __toESM(require("path"), 1);
 var ClineMcpJsonParseError = class extends Error {
   constructor(configPath) {
@@ -5591,7 +5560,7 @@ function stripLeadingLineComments10(text) {
 }
 async function pathExists14(filePath) {
   try {
-    await fs25.access(filePath);
+    await fs23.access(filePath);
     return true;
   } catch {
     return false;
@@ -5624,17 +5593,17 @@ function mergeClineMcpConfigObject(existing, memoraone) {
 }
 async function writeClineMcpJsonAtomic(filePath, content) {
   const dir = path31.dirname(filePath);
-  await fs25.mkdir(dir, { recursive: true });
+  await fs23.mkdir(dir, { recursive: true });
   const tmpPath = path31.join(
     dir,
     `.${path31.basename(filePath)}.${process.pid}.${(0, import_node_crypto16.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs25.writeFile(tmpPath, content, "utf8");
-    await fs25.rename(tmpPath, filePath);
+    await fs23.writeFile(tmpPath, content, "utf8");
+    await fs23.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs25.unlink(tmpPath);
+      await fs23.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -5657,13 +5626,13 @@ function validateClineMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig10(filePath) {
-  const raw = await fs25.readFile(filePath, "utf8");
+  const raw = await fs23.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments10(raw));
 }
 async function backupConfigFile4(filePath) {
   const backupPath = `${filePath}.bak-${formatClineBackupTimestamp()}`;
-  await fs25.copyFile(filePath, backupPath);
+  await fs23.copyFile(filePath, backupPath);
   return backupPath;
 }
 async function buildClineMemoraoneServer(options) {
@@ -5729,12 +5698,12 @@ async function setupClineMcpConfig(options) {
   if (options.dryRun) return { activeConfigPath: configPath, outcome, memoraone };
   const backupPath = existed ? await backupConfigFile4(configPath) : void 0;
   await writeClineMcpJsonAtomic(configPath, JSON.stringify(merged, null, 2) + "\n");
-  validateClineMcpConfig(JSON.parse(await fs25.readFile(configPath, "utf8")), memoraone);
+  validateClineMcpConfig(JSON.parse(await fs23.readFile(configPath, "utf8")), memoraone);
   return { activeConfigPath: configPath, outcome, backupPath, memoraone };
 }
 
 // src/copilotCliMcpConfig.ts
-var fs26 = __toESM(require("fs/promises"), 1);
+var fs24 = __toESM(require("fs/promises"), 1);
 var path32 = __toESM(require("path"), 1);
 var import_node_crypto17 = require("crypto");
 var CopilotCliMcpJsonParseError = class extends Error {
@@ -5751,7 +5720,7 @@ function stripLeadingLineComments11(text) {
 }
 async function pathExists15(filePath) {
   try {
-    await fs26.access(filePath);
+    await fs24.access(filePath);
     return true;
   } catch {
     return false;
@@ -5792,17 +5761,17 @@ function mergeCopilotCliMcpConfigObject(existing, memoraone) {
 }
 async function writeCopilotCliMcpJsonAtomic(filePath, content) {
   const dir = path32.dirname(filePath);
-  await fs26.mkdir(dir, { recursive: true });
+  await fs24.mkdir(dir, { recursive: true });
   const tmpPath = path32.join(
     dir,
     `.${path32.basename(filePath)}.${process.pid}.${(0, import_node_crypto17.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs26.writeFile(tmpPath, content, "utf8");
-    await fs26.rename(tmpPath, filePath);
+    await fs24.writeFile(tmpPath, content, "utf8");
+    await fs24.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs26.unlink(tmpPath);
+      await fs24.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -5827,7 +5796,7 @@ function validateCopilotCliMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig11(filePath) {
-  const raw = await fs26.readFile(filePath, "utf8");
+  const raw = await fs24.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments11(raw));
 }
@@ -5907,7 +5876,7 @@ async function setupCopilotCliMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeCopilotCliMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs26.readFile(projectPath, "utf8");
+  const verifyRaw = await fs24.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments11(verifyRaw));
   validateCopilotCliMcpConfig(verifyParsed, memoraone);
   return {
@@ -5917,7 +5886,7 @@ async function setupCopilotCliMcpConfig(options) {
 }
 
 // src/auggieMcpConfig.ts
-var fs27 = __toESM(require("fs/promises"), 1);
+var fs25 = __toESM(require("fs/promises"), 1);
 var path33 = __toESM(require("path"), 1);
 var import_node_crypto18 = require("crypto");
 var AuggieMcpJsonParseError = class extends Error {
@@ -5934,7 +5903,7 @@ function stripLeadingLineComments12(text) {
 }
 async function pathExists16(filePath) {
   try {
-    await fs27.access(filePath);
+    await fs25.access(filePath);
     return true;
   } catch {
     return false;
@@ -5974,17 +5943,17 @@ function mergeAuggieMcpConfigObject(existing, memoraone) {
 }
 async function writeAuggieMcpJsonAtomic(filePath, content) {
   const dir = path33.dirname(filePath);
-  await fs27.mkdir(dir, { recursive: true });
+  await fs25.mkdir(dir, { recursive: true });
   const tmpPath = path33.join(
     dir,
     `.${path33.basename(filePath)}.${process.pid}.${(0, import_node_crypto18.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs27.writeFile(tmpPath, content, "utf8");
-    await fs27.rename(tmpPath, filePath);
+    await fs25.writeFile(tmpPath, content, "utf8");
+    await fs25.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs27.unlink(tmpPath);
+      await fs25.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -6009,7 +5978,7 @@ function validateAuggieMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig12(filePath) {
-  const raw = await fs27.readFile(filePath, "utf8");
+  const raw = await fs25.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments12(raw));
 }
@@ -6089,7 +6058,7 @@ async function setupAuggieMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeAuggieMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs27.readFile(projectPath, "utf8");
+  const verifyRaw = await fs25.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments12(verifyRaw));
   validateAuggieMcpConfig(verifyParsed, memoraone);
   return {
@@ -6099,7 +6068,7 @@ async function setupAuggieMcpConfig(options) {
 }
 
 // src/geminiCliMcpConfig.ts
-var fs28 = __toESM(require("fs/promises"), 1);
+var fs26 = __toESM(require("fs/promises"), 1);
 var path34 = __toESM(require("path"), 1);
 var import_node_crypto19 = require("crypto");
 var GeminiCliMcpJsonParseError = class extends Error {
@@ -6116,7 +6085,7 @@ function stripLeadingLineComments13(text) {
 }
 async function pathExists17(filePath) {
   try {
-    await fs28.access(filePath);
+    await fs26.access(filePath);
     return true;
   } catch {
     return false;
@@ -6156,17 +6125,17 @@ function mergeGeminiCliMcpConfigObject(existing, memoraone) {
 }
 async function writeGeminiCliMcpJsonAtomic(filePath, content) {
   const dir = path34.dirname(filePath);
-  await fs28.mkdir(dir, { recursive: true });
+  await fs26.mkdir(dir, { recursive: true });
   const tmpPath = path34.join(
     dir,
     `.${path34.basename(filePath)}.${process.pid}.${(0, import_node_crypto19.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs28.writeFile(tmpPath, content, "utf8");
-    await fs28.rename(tmpPath, filePath);
+    await fs26.writeFile(tmpPath, content, "utf8");
+    await fs26.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs28.unlink(tmpPath);
+      await fs26.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -6191,7 +6160,7 @@ function validateGeminiCliMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig13(filePath) {
-  const raw = await fs28.readFile(filePath, "utf8");
+  const raw = await fs26.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments13(raw));
 }
@@ -6271,7 +6240,7 @@ async function setupGeminiCliMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeGeminiCliMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs28.readFile(projectPath, "utf8");
+  const verifyRaw = await fs26.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments13(verifyRaw));
   validateGeminiCliMcpConfig(verifyParsed, memoraone);
   return {
@@ -6282,7 +6251,7 @@ async function setupGeminiCliMcpConfig(options) {
 
 // src/antigravityMcpConfig.ts
 var fsSync = __toESM(require("fs"), 1);
-var fs29 = __toESM(require("fs/promises"), 1);
+var fs27 = __toESM(require("fs/promises"), 1);
 var os9 = __toESM(require("os"), 1);
 var path35 = __toESM(require("path"), 1);
 var import_node_crypto20 = require("crypto");
@@ -6300,7 +6269,7 @@ function stripLeadingLineComments14(text) {
 }
 async function pathExists18(filePath) {
   try {
-    await fs29.access(filePath);
+    await fs27.access(filePath);
     return true;
   } catch {
     return false;
@@ -6364,17 +6333,17 @@ function stripMemoraoneFromAntigravityConfigObject(existing) {
 }
 async function writeAntigravityMcpJsonAtomic(filePath, content) {
   const dir = path35.dirname(filePath);
-  await fs29.mkdir(dir, { recursive: true });
+  await fs27.mkdir(dir, { recursive: true });
   const tmpPath = path35.join(
     dir,
     `.${path35.basename(filePath)}.${process.pid}.${(0, import_node_crypto20.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs29.writeFile(tmpPath, content, "utf8");
-    await fs29.rename(tmpPath, filePath);
+    await fs27.writeFile(tmpPath, content, "utf8");
+    await fs27.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs29.unlink(tmpPath);
+      await fs27.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -6400,7 +6369,7 @@ function validateAntigravityMcpConfig(parsed2, expected, serverName = CANONICAL_
   }
 }
 async function readJsonConfig14(filePath) {
-  const raw = await fs29.readFile(filePath, "utf8");
+  const raw = await fs27.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments14(raw));
 }
@@ -6520,7 +6489,7 @@ async function setupAntigravityMcpConfig(options) {
       };
     }
     await writeAntigravityMcpJsonAtomic(activePath, body);
-    const verifyRaw = await fs29.readFile(activePath, "utf8");
+    const verifyRaw = await fs27.readFile(activePath, "utf8");
     const verifyParsed = JSON.parse(stripLeadingLineComments14(verifyRaw));
     validateAntigravityMcpConfig(verifyParsed, memoraone, options.ownership ? memoraoneServerNameForRepositoryBinding(options.ownership.repositoryBindingId) : CANONICAL_MEMORAONE_MCP_SERVER_NAME);
     return {
@@ -6559,7 +6528,7 @@ async function setupAntigravityMcpConfig(options) {
   }
   if (!activeAlreadyCorrect) {
     await writeAntigravityMcpJsonAtomic(activePath, body);
-    const verifyRaw = await fs29.readFile(activePath, "utf8");
+    const verifyRaw = await fs27.readFile(activePath, "utf8");
     const verifyParsed = JSON.parse(stripLeadingLineComments14(verifyRaw));
     validateAntigravityMcpConfig(verifyParsed, memoraone, options.ownership ? memoraoneServerNameForRepositoryBinding(options.ownership.repositoryBindingId) : CANONICAL_MEMORAONE_MCP_SERVER_NAME);
   }
@@ -6602,7 +6571,7 @@ async function setupAntigravityMcpConfig(options) {
 }
 
 // src/gooseMcpConfig.ts
-var fs30 = __toESM(require("fs/promises"), 1);
+var fs28 = __toESM(require("fs/promises"), 1);
 var os10 = __toESM(require("os"), 1);
 var path36 = __toESM(require("path"), 1);
 var import_node_crypto21 = require("crypto");
@@ -6619,7 +6588,7 @@ var GooseMcpYamlParseError = class extends Error {
 var MEMORAONE_PACKAGE_SPEC_RE2 = /@memoraone\/mcp(?:@|$)/;
 async function pathExists19(filePath) {
   try {
-    await fs30.access(filePath);
+    await fs28.access(filePath);
     return true;
   } catch {
     return false;
@@ -6743,17 +6712,17 @@ function mergeGooseMcpConfigObject(existing, memoraone, ownership) {
 }
 async function writeGooseMcpYamlAtomic(filePath, content) {
   const dir = path36.dirname(filePath);
-  await fs30.mkdir(dir, { recursive: true });
+  await fs28.mkdir(dir, { recursive: true });
   const tmpPath = path36.join(
     dir,
     `.${path36.basename(filePath)}.${process.pid}.${(0, import_node_crypto21.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs30.writeFile(tmpPath, content, "utf8");
-    await fs30.rename(tmpPath, filePath);
+    await fs28.writeFile(tmpPath, content, "utf8");
+    await fs28.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs30.unlink(tmpPath);
+      await fs28.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -6849,7 +6818,7 @@ async function setupGooseMcpConfig(options) {
   let existing = null;
   if (exists) {
     try {
-      const raw = await fs30.readFile(activePath, "utf8");
+      const raw = await fs28.readFile(activePath, "utf8");
       existing = parseGooseYaml(raw);
     } catch {
       throw new GooseMcpYamlParseError(activePath);
@@ -6874,7 +6843,7 @@ async function setupGooseMcpConfig(options) {
     };
   }
   await writeGooseMcpYamlAtomic(activePath, body);
-  const verifyRaw = await fs30.readFile(activePath, "utf8");
+  const verifyRaw = await fs28.readFile(activePath, "utf8");
   let verifyParsed;
   try {
     verifyParsed = (0, import_yaml2.parse)(verifyRaw);
@@ -6890,7 +6859,7 @@ async function setupGooseMcpConfig(options) {
 }
 
 // src/junieMcpConfig.ts
-var fs31 = __toESM(require("fs/promises"), 1);
+var fs29 = __toESM(require("fs/promises"), 1);
 var path37 = __toESM(require("path"), 1);
 var import_node_crypto22 = require("crypto");
 var JunieMcpJsonParseError = class extends Error {
@@ -6907,7 +6876,7 @@ function stripLeadingLineComments15(text) {
 }
 async function pathExists20(filePath) {
   try {
-    await fs31.access(filePath);
+    await fs29.access(filePath);
     return true;
   } catch {
     return false;
@@ -6947,17 +6916,17 @@ function mergeJunieMcpConfigObject(existing, memoraone) {
 }
 async function writeJunieMcpJsonAtomic(filePath, content) {
   const dir = path37.dirname(filePath);
-  await fs31.mkdir(dir, { recursive: true });
+  await fs29.mkdir(dir, { recursive: true });
   const tmpPath = path37.join(
     dir,
     `.${path37.basename(filePath)}.${process.pid}.${(0, import_node_crypto22.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs31.writeFile(tmpPath, content, "utf8");
-    await fs31.rename(tmpPath, filePath);
+    await fs29.writeFile(tmpPath, content, "utf8");
+    await fs29.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs31.unlink(tmpPath);
+      await fs29.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -6982,7 +6951,7 @@ function validateJunieMcpConfig(parsed2, expected) {
   }
 }
 async function readJsonConfig15(filePath) {
-  const raw = await fs31.readFile(filePath, "utf8");
+  const raw = await fs29.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments15(raw));
 }
@@ -7062,7 +7031,7 @@ async function setupJunieMcpConfig(options) {
     return { outcome: exists ? "updated" : "created", memoraone };
   }
   await writeJunieMcpJsonAtomic(projectPath, body);
-  const verifyRaw = await fs31.readFile(projectPath, "utf8");
+  const verifyRaw = await fs29.readFile(projectPath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments15(verifyRaw));
   validateJunieMcpConfig(verifyParsed, memoraone);
   return {
@@ -7072,7 +7041,7 @@ async function setupJunieMcpConfig(options) {
 }
 
 // src/xcodeMcpConfig.ts
-var fs32 = __toESM(require("fs/promises"), 1);
+var fs30 = __toESM(require("fs/promises"), 1);
 var os11 = __toESM(require("os"), 1);
 var path38 = __toESM(require("path"), 1);
 var import_node_crypto23 = require("crypto");
@@ -7090,7 +7059,7 @@ function stripLeadingLineComments16(text) {
 }
 async function pathExists21(filePath) {
   try {
-    await fs32.access(filePath);
+    await fs30.access(filePath);
     return true;
   } catch {
     return false;
@@ -7131,17 +7100,17 @@ function mergeXcodeMcpConfigObject(existing, memoraone, ownership) {
 }
 async function writeXcodeMcpJsonAtomic(filePath, content) {
   const dir = path38.dirname(filePath);
-  await fs32.mkdir(dir, { recursive: true });
+  await fs30.mkdir(dir, { recursive: true });
   const tmpPath = path38.join(
     dir,
     `.${path38.basename(filePath)}.${process.pid}.${(0, import_node_crypto23.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs32.writeFile(tmpPath, content, "utf8");
-    await fs32.rename(tmpPath, filePath);
+    await fs30.writeFile(tmpPath, content, "utf8");
+    await fs30.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs32.unlink(tmpPath);
+      await fs30.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -7167,7 +7136,7 @@ function validateXcodeMcpConfig(parsed2, expected, serverName = CANONICAL_MEMORA
   }
 }
 async function readJsonConfig16(filePath) {
-  const raw = await fs32.readFile(filePath, "utf8");
+  const raw = await fs30.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments16(raw));
 }
@@ -7251,7 +7220,7 @@ async function setupXcodeMcpConfig(options) {
     };
   }
   await writeXcodeMcpJsonAtomic(activePath, body);
-  const verifyRaw = await fs32.readFile(activePath, "utf8");
+  const verifyRaw = await fs30.readFile(activePath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments16(verifyRaw));
   validateXcodeMcpConfig(verifyParsed, memoraone, options.ownership ? memoraoneServerNameForRepositoryBinding(options.ownership.repositoryBindingId) : CANONICAL_MEMORAONE_MCP_SERVER_NAME);
   return {
@@ -7262,7 +7231,7 @@ async function setupXcodeMcpConfig(options) {
 }
 
 // src/copilotJetBrainsMcpConfig.ts
-var fs33 = __toESM(require("fs/promises"), 1);
+var fs31 = __toESM(require("fs/promises"), 1);
 var os12 = __toESM(require("os"), 1);
 var path39 = __toESM(require("path"), 1);
 var import_node_crypto24 = require("crypto");
@@ -7280,7 +7249,7 @@ function stripLeadingLineComments17(text) {
 }
 async function pathExists22(filePath) {
   try {
-    await fs33.access(filePath);
+    await fs31.access(filePath);
     return true;
   } catch {
     return false;
@@ -7321,17 +7290,17 @@ function mergeCopilotJetBrainsMcpConfigObject(existing, memoraone, ownership) {
 }
 async function writeCopilotJetBrainsMcpJsonAtomic(filePath, content) {
   const dir = path39.dirname(filePath);
-  await fs33.mkdir(dir, { recursive: true });
+  await fs31.mkdir(dir, { recursive: true });
   const tmpPath = path39.join(
     dir,
     `.${path39.basename(filePath)}.${process.pid}.${(0, import_node_crypto24.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs33.writeFile(tmpPath, content, "utf8");
-    await fs33.rename(tmpPath, filePath);
+    await fs31.writeFile(tmpPath, content, "utf8");
+    await fs31.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs33.unlink(tmpPath);
+      await fs31.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -7361,7 +7330,7 @@ function validateCopilotJetBrainsMcpConfig(parsed2, expected, serverName = CANON
   }
 }
 async function readJsonConfig17(filePath) {
-  const raw = await fs33.readFile(filePath, "utf8");
+  const raw = await fs31.readFile(filePath, "utf8");
   if (raw.trim() === "") return null;
   return JSON.parse(stripLeadingLineComments17(raw));
 }
@@ -7445,7 +7414,7 @@ async function setupCopilotJetBrainsMcpConfig(options) {
     };
   }
   await writeCopilotJetBrainsMcpJsonAtomic(activePath, body);
-  const verifyRaw = await fs33.readFile(activePath, "utf8");
+  const verifyRaw = await fs31.readFile(activePath, "utf8");
   const verifyParsed = JSON.parse(stripLeadingLineComments17(verifyRaw));
   validateCopilotJetBrainsMcpConfig(verifyParsed, memoraone, options.ownership ? memoraoneServerNameForRepositoryBinding(options.ownership.repositoryBindingId) : CANONICAL_MEMORAONE_MCP_SERVER_NAME);
   return {
@@ -7499,7 +7468,7 @@ function assertUnderRepoRoot(repoRoot, absPath) {
 }
 async function pathExists23(filePath) {
   try {
-    await fs34.access(filePath);
+    await fs32.access(filePath);
     return true;
   } catch {
     return false;
@@ -7588,17 +7557,17 @@ function buildVscodeMcpJsonBody(existing, options = {}) {
 }
 async function writeSharedMcpJsonAtomic(filePath, content) {
   const dir = path40.dirname(filePath);
-  await fs34.mkdir(dir, { recursive: true });
+  await fs32.mkdir(dir, { recursive: true });
   const tmpPath = path40.join(
     dir,
     `.${path40.basename(filePath)}.${process.pid}.${(0, import_node_crypto25.randomBytes)(8).toString("hex")}.tmp`
   );
   try {
-    await fs34.writeFile(tmpPath, content, "utf8");
-    await fs34.rename(tmpPath, filePath);
+    await fs32.writeFile(tmpPath, content, "utf8");
+    await fs32.rename(tmpPath, filePath);
   } catch (err) {
     try {
-      await fs34.unlink(tmpPath);
+      await fs32.unlink(tmpPath);
     } catch {
     }
     throw err;
@@ -7627,7 +7596,7 @@ async function writeClaudeCodeMcpJson(repoRoot, buildBody, opts) {
   let raw = "";
   let existed = false;
   try {
-    raw = await fs34.readFile(abs, "utf8");
+    raw = await fs32.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
@@ -7659,28 +7628,28 @@ async function writeManagedMarkdown(repoRoot, relPath, fullContent, opts) {
   let prior = "";
   let existed = false;
   try {
-    prior = await fs34.readFile(abs, "utf8");
+    prior = await fs32.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
   }
   if (!existed) {
     if (opts.dryRun) return "created";
-    await fs34.mkdir(path40.dirname(abs), { recursive: true });
-    await fs34.writeFile(abs, fullContent, "utf8");
+    await fs32.mkdir(path40.dirname(abs), { recursive: true });
+    await fs32.writeFile(abs, fullContent, "utf8");
     return "created";
   }
   if (prior.includes(MANAGED_MARKER)) {
     if (prior === fullContent) return "skipped";
     if (opts.dryRun) return "updated";
-    await fs34.mkdir(path40.dirname(abs), { recursive: true });
-    await fs34.writeFile(abs, fullContent, "utf8");
+    await fs32.mkdir(path40.dirname(abs), { recursive: true });
+    await fs32.writeFile(abs, fullContent, "utf8");
     return "updated";
   }
   if (!opts.force) return "skipped-untracked";
   if (opts.dryRun) return "updated";
-  await fs34.mkdir(path40.dirname(abs), { recursive: true });
-  await fs34.writeFile(abs, fullContent, "utf8");
+  await fs32.mkdir(path40.dirname(abs), { recursive: true });
+  await fs32.writeFile(abs, fullContent, "utf8");
   return "updated";
 }
 async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
@@ -7689,7 +7658,7 @@ async function writeIdeMcpJson(repoRoot, relPath, buildBody, opts) {
   let raw = "";
   let existed = false;
   try {
-    raw = await fs34.readFile(abs, "utf8");
+    raw = await fs32.readFile(abs, "utf8");
     existed = true;
   } catch (err) {
     if (err?.code !== "ENOENT") throw err;
@@ -9112,7 +9081,7 @@ alwaysApply: true
 }
 
 // src/localState/replaceRootLocalState.ts
-var fs35 = __toESM(require("fs/promises"), 1);
+var fs33 = __toESM(require("fs/promises"), 1);
 var path41 = __toESM(require("path"), 1);
 var WORKSPACE_MAP_FILENAME = "workspaces.json";
 var FINGERPRINT_REGEX = /^[0-9a-f]{64}$/i;
@@ -9234,7 +9203,7 @@ async function snapshotAndRemoveRootLocalState(workspaceRoot, options = {}) {
     } catch {
     }
     try {
-      await fs35.unlink(getBindingFilePath(id, options.homeDir));
+      await fs33.unlink(getBindingFilePath(id, options.homeDir));
     } catch (err) {
       if (err?.code !== "ENOENT") throw err;
     }
@@ -9257,7 +9226,7 @@ async function restoreRootLocalState(snapshot, options = {}) {
     } catch {
     }
     try {
-      await fs35.unlink(getBindingFilePath(id, options.homeDir));
+      await fs33.unlink(getBindingFilePath(id, options.homeDir));
     } catch (err) {
       if (err?.code !== "ENOENT") throw err;
     }
@@ -9297,7 +9266,7 @@ async function restoreRootLocalState(snapshot, options = {}) {
 var path42 = __toESM(require("path"), 1);
 var import_node_child_process6 = require("child_process");
 var import_node_util5 = require("util");
-var fs36 = __toESM(require("fs/promises"), 1);
+var fs34 = __toESM(require("fs/promises"), 1);
 var execFileAsync5 = (0, import_node_util5.promisify)(import_node_child_process6.execFile);
 var CLINE_HUB_DAEMON_MARKER = "--cline-hub-daemon";
 function parseClineHubCwdFromCommandLine(commandLine) {
@@ -9344,9 +9313,9 @@ async function defaultListClineHubProcesses() {
   return parseClineHubProcessLines(stdout.split("\n"));
 }
 async function defaultRemoveSocket2(socketPath) {
-  await fs36.unlink(socketPath);
+  await fs34.unlink(socketPath);
   try {
-    await fs36.unlink(bindingSidecarPath(socketPath));
+    await fs34.unlink(bindingSidecarPath(socketPath));
   } catch {
   }
 }
@@ -9557,10 +9526,10 @@ function normalizeGitRemote(remoteUrl) {
   normalized = normalized.replace(/\/+$/, "");
   return normalized.toLowerCase() || null;
 }
-async function detectLegacyM1Warning2(workspaceRoot) {
+async function detectLegacyM1Warning(workspaceRoot) {
   const candidate = path43.join(path43.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
   try {
-    await fs37.access(candidate);
+    await fs35.access(candidate);
     return candidate;
   } catch {
     return void 0;
@@ -9601,7 +9570,7 @@ async function runConnectCommand(options) {
     resolvedMode = { kind: "local", cliPath };
   }
   const fingerprint = resolveRepoFingerprint(cwd2);
-  const legacyM1WarningPath = await detectLegacyM1Warning2(cwd2);
+  const legacyM1WarningPath = await detectLegacyM1Warning(cwd2);
   if (legacyM1WarningPath) {
     process.stderr.write(
       `[memoraone-mcp] warning: ignoring legacy ${path43.basename(legacyM1WarningPath)} at ${legacyM1WarningPath} (credentials and binding are package-managed)