@memoraone/mcp 0.1.48 → 0.1.50

package/dist/cli.cjs

@@ -231,7 +231,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@memoraone/mcp",
-      version: "0.1.48",
+      version: "0.1.50",
       type: "module",
       main: "dist/index.cjs",
       exports: {
@@ -1273,19 +1273,9 @@ var init_tokenRefreshCoordinator = __esm({
 });
 
 // src/localState/resolveLocalBinding.ts
-async function detectLegacyM1Warning(workspaceRoot) {
-  const candidate = path9.join(path9.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
-  try {
-    await fs6.access(candidate);
-    return candidate;
-  } catch {
-    return void 0;
-  }
-}
 async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   const resolved = path9.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") {
@@ -1309,8 +1299,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
       return {
         repositoryBindingId: record.repositoryBindingId,
         identity,
-        created: false,
-        legacyM1WarningPath
+        created: false
       };
     }
   }
@@ -1334,8 +1323,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
         repositoryBindingId: record.repositoryBindingId,
         identity,
         created: false,
-        renamedFrom: lookup.previousPath,
-        legacyM1WarningPath
+        renamedFrom: lookup.previousPath
       };
     }
   }
@@ -1348,8 +1336,7 @@ async function ensureRepositoryBindingForRoot(workspaceRoot, options = {}) {
   return {
     repositoryBindingId,
     identity,
-    created: true,
-    legacyM1WarningPath
+    created: true
   };
 }
 async function lookupLocalBindingIdentity(workspaceRoot, options = {}) {
@@ -1378,7 +1365,7 @@ async function lookupLocalBindingIdentity(workspaceRoot, options = {}) {
 }
 async function resolveLocalBinding(workspaceRoot, options = {}) {
   const resolved = path9.resolve(workspaceRoot);
-  const { repositoryBindingId, legacyM1WarningPath } = await ensureRepositoryBindingForRoot(
+  const { repositoryBindingId } = await ensureRepositoryBindingForRoot(
     resolved,
     { ...options, createIfMissing: false }
   );
@@ -1421,16 +1408,13 @@ async function resolveLocalBinding(workspaceRoot, options = {}) {
     installationPublicId: record.installationPublicId ?? creds.installationPublicId,
     environment: record.environment,
     bindingSource: "local-binding",
-    status: record.status,
-    legacyM1WarningPath
+    status: record.status
   };
 }
-var fs6, path9;
+var path9;
 var init_resolveLocalBinding = __esm({
   "src/localState/resolveLocalBinding.ts"() {
-    fs6 = __toESM(require("fs/promises"), 1);
     path9 = __toESM(require("path"), 1);
-    init_projectBinding();
     init_bindingStore();
     init_installationCredentials();
     init_pathIndex();
@@ -1456,23 +1440,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 = path10.join(path10.resolve(workspaceRoot), CANONICAL_M1_FILENAME);
-  try {
-    await fs7.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) {
@@ -1482,12 +1452,11 @@ 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));
     } catch (err) {
-      if (err instanceof ReconnectRequiredError) {
+      if (err instanceof ReconnectRequiredError && (err.message.includes("No local binding for workspace") || err.message.includes("No local MemoraOne binding for this workspace"))) {
         continue;
       }
       throw err;
@@ -1624,10 +1593,9 @@ function decodeResolvedBinding(value) {
     status
   };
 }
-var fs7, path10, uuidRegex, CANONICAL_M1_FILENAME;
+var path10, uuidRegex, CANONICAL_M1_FILENAME;
 var init_projectBinding = __esm({
   "src/projectBinding.ts"() {
-    fs7 = __toESM(require("fs/promises"), 1);
     path10 = __toESM(require("path"), 1);
     init_resolveLocalBinding();
     init_bindingStore();
@@ -1671,7 +1639,7 @@ function parseSidecarRecord(raw) {
 }
 function readBindingSidecarRecord(socketPath) {
   try {
-    const raw = fs8.readFileSync(bindingSidecarPath(socketPath), "utf8");
+    const raw = fs6.readFileSync(bindingSidecarPath(socketPath), "utf8");
     return parseSidecarRecord(raw);
   } catch {
     return null;
@@ -1686,14 +1654,14 @@ function readBindingSidecar(socketPath) {
 }
 function removeBindingSidecar(socketPath) {
   try {
-    fs8.unlinkSync(bindingSidecarPath(socketPath));
+    fs6.unlinkSync(bindingSidecarPath(socketPath));
   } catch {
   }
 }
 function removeDaemonSocketArtifacts(socketPath) {
   removeBindingSidecar(socketPath);
   try {
-    fs8.unlinkSync(socketPath);
+    fs6.unlinkSync(socketPath);
   } catch {
   }
 }
@@ -1737,10 +1705,10 @@ function verifyDaemonSidecarBinding(socketPath, expected, env2 = process.env, id
   }
   return sidecar;
 }
-var fs8, path11;
+var fs6, path11;
 var init_bindingSidecar = __esm({
   "src/bindingSidecar.ts"() {
-    fs8 = __toESM(require("fs"), 1);
+    fs6 = __toESM(require("fs"), 1);
     path11 = __toESM(require("path"), 1);
     init_bindingIdentity();
     init_projectBinding();
@@ -1849,7 +1817,7 @@ async function resolveBindingFromWorkspaceRoots(workspaceRoots, options = {}) {
         })
       );
     } catch (err) {
-      if (err instanceof Error && (err.message.includes("No local MemoraOne binding") || err.message.includes("memoraone-mcp connect") || err.name === "ReconnectRequiredError")) {
+      if (err instanceof Error && (err.message.includes("No local MemoraOne binding for this workspace") || err.message.includes("No local binding for workspace"))) {
         continue;
       }
       throw err;
@@ -1930,7 +1898,7 @@ var init_initializeBinding = __esm({
 // src/resolveBuiltCliPath.ts
 async function pathExists(filePath) {
   try {
-    await fs9.access(filePath);
+    await fs7.access(filePath);
     return true;
   } catch {
     return false;
@@ -1994,10 +1962,10 @@ async function resolveBuiltCliPathAsync(options) {
   }
   return null;
 }
-var fs9, path13, MONOREPO_CLI_REL;
+var fs7, path13, MONOREPO_CLI_REL;
 var init_resolveBuiltCliPath = __esm({
   "src/resolveBuiltCliPath.ts"() {
-    fs9 = __toESM(require("fs/promises"), 1);
+    fs7 = __toESM(require("fs/promises"), 1);
     path13 = __toESM(require("path"), 1);
     MONOREPO_CLI_REL = path13.join("packages", "mcp", "dist", "cli.cjs");
   }
@@ -2383,7 +2351,7 @@ function buildMemoraoneCursorMcpServer(options) {
 }
 async function pathExists2(filePath) {
   try {
-    await fs10.access(filePath);
+    await fs8.access(filePath);
     return true;
   } catch {
     return false;
@@ -2434,7 +2402,7 @@ async function isWorkingNpx(npxPath) {
     if (!await pathExists2(npxPath)) return false;
     if (process.platform !== "win32") {
       try {
-        await fs10.access(npxPath, fs10.constants.X_OK);
+        await fs8.access(npxPath, fs8.constants.X_OK);
       } catch {
         return false;
       }
@@ -2615,7 +2583,7 @@ function getCursorRepoMcpConfigPath(repoRoot) {
 }
 async function readCursorMcpConfigObject(configPath) {
   try {
-    const raw = await fs10.readFile(configPath, "utf8");
+    const raw = await fs8.readFile(configPath, "utf8");
     return JSON.parse(stripLeadingLineComments(raw));
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
@@ -2633,17 +2601,17 @@ async function removeMemoraoneFromCursorGlobalConfig(options) {
     return { changed: true, backupPath: `${configPath}.backup-<timestamp>` };
   }
   const backupPath = `${configPath}.backup-${formatBackupTimestamp()}`;
-  await fs10.copyFile(configPath, backupPath);
+  await fs8.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 fs10.unlink(configPath);
+    await fs8.unlink(configPath);
     return { changed: true, backupPath };
   }
   const next = { ...parsed2, mcpServers };
-  await fs10.mkdir(path16.dirname(configPath), { recursive: true });
-  await fs10.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
+  await fs8.mkdir(path16.dirname(configPath), { recursive: true });
+  await fs8.writeFile(configPath, JSON.stringify(next, null, 2) + "\n", "utf8");
   return { changed: true, backupPath };
 }
 async function auditCursorMcpConfig(options) {
@@ -2749,10 +2717,10 @@ function logCursorMcpCliSummary(info, dryRun, opts) {
     );
   }
 }
-var fs10, os4, path16, import_node_child_process2, import_node_util2, execFileAsync2, MEMORAONE_PROD_API_URL, MEMORAONE_LOCAL_API_URL, MEMORAONE_STAGING_API_URL, MEMORAONE_STAGING_API_URL_PREFIX;
+var fs8, os4, path16, import_node_child_process2, import_node_util2, execFileAsync2, MEMORAONE_PROD_API_URL, MEMORAONE_LOCAL_API_URL, MEMORAONE_STAGING_API_URL, MEMORAONE_STAGING_API_URL_PREFIX;
 var init_cursorGlobalMcpConfig = __esm({
   "src/cursorGlobalMcpConfig.ts"() {
-    fs10 = __toESM(require("fs/promises"), 1);
+    fs8 = __toESM(require("fs/promises"), 1);
     os4 = __toESM(require("os"), 1);
     path16 = __toESM(require("path"), 1);
     import_node_child_process2 = require("child_process");
@@ -2967,7 +2935,7 @@ async function defaultListSocketPaths(projectId) {
   const baseDir = getMcpBaseDir();
   let entries;
   try {
-    entries = await fs11.readdir(baseDir);
+    entries = await fs9.readdir(baseDir);
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
     if (code === "ENOENT") {
@@ -3004,7 +2972,7 @@ async function defaultListSocketPathsForWorkspaceRoot(workspaceRoot) {
   const baseDir = getMcpBaseDir();
   let entries;
   try {
-    entries = await fs11.readdir(baseDir);
+    entries = await fs9.readdir(baseDir);
   } catch (err) {
     const code = err && typeof err === "object" && "code" in err ? err.code : void 0;
     if (code === "ENOENT") {
@@ -3058,9 +3026,9 @@ async function defaultKillProcess(pid, signal = "SIGTERM") {
   process.kill(pid, signal);
 }
 async function defaultRemoveSocket(socketPath) {
-  await fs11.unlink(socketPath);
+  await fs9.unlink(socketPath);
   try {
-    await fs11.unlink(bindingSidecarPath(socketPath));
+    await fs9.unlink(bindingSidecarPath(socketPath));
   } catch {
   }
 }
@@ -3457,10 +3425,10 @@ async function cliCleanup(argv) {
   }
   return result.exitCode;
 }
-var fs11, path17, readline, import_node_child_process3, import_node_util3, import_node_process, execFileAsync3, DAEMON_PROJECT_ID_RE, DAEMON_BINDING_ID_RE, PROJECT_ID_RE, MEMORAONE_MCP_COMMAND_RE, CLEANUP_PROJECT_ID_REQUIRED_ERROR;
+var fs9, path17, readline, import_node_child_process3, import_node_util3, import_node_process, execFileAsync3, DAEMON_PROJECT_ID_RE, DAEMON_BINDING_ID_RE, PROJECT_ID_RE, MEMORAONE_MCP_COMMAND_RE, CLEANUP_PROJECT_ID_REQUIRED_ERROR;
 var init_cleanup = __esm({
   "src/cleanup.ts"() {
-    fs11 = __toESM(require("fs/promises"), 1);
+    fs9 = __toESM(require("fs/promises"), 1);
     path17 = __toESM(require("path"), 1);
     readline = __toESM(require("readline/promises"), 1);
     import_node_child_process3 = require("child_process");
@@ -3503,18 +3471,18 @@ var init_configUtils = __esm({
 });
 
 // src/config.ts
-var process2, fs12, path18, dotenv, import_v4, dotenvPath, EnvSchema, requiredEnvVars, missingEnvVars, parsed, resolvedApiUrl, parseBooleanFlag2, config2;
+var process2, fs10, path18, dotenv, import_v4, dotenvPath, EnvSchema, requiredEnvVars, missingEnvVars, parsed, resolvedApiUrl, parseBooleanFlag2, config2;
 var init_config = __esm({
   "src/config.ts"() {
     process2 = __toESM(require("process"), 1);
-    fs12 = __toESM(require("fs"), 1);
+    fs10 = __toESM(require("fs"), 1);
     path18 = __toESM(require("path"), 1);
     dotenv = __toESM(require("dotenv"), 1);
     import_v4 = require("zod/v4");
     init_configUtils();
     init_socketPaths();
     dotenvPath = path18.resolve(process2.cwd(), ".env");
-    if (fs12.existsSync(dotenvPath)) {
+    if (fs10.existsSync(dotenvPath)) {
       try {
         dotenv.config({ path: dotenvPath });
       } catch (err) {
@@ -3618,10 +3586,10 @@ function resolveRepoFingerprint(cwd2) {
     source: "path-fallback"
   };
 }
-var fs13, path19, crypto2, parseBooleanFlag3, debugEnabled2, debugLog, normalizeRemoteUrl, sha256, resolveGitDir, findGitRoot, readOriginRemote;
+var fs11, path19, crypto2, parseBooleanFlag3, debugEnabled2, debugLog, normalizeRemoteUrl, sha256, resolveGitDir, findGitRoot, readOriginRemote;
 var init_repoFingerprint = __esm({
   "src/repoFingerprint.ts"() {
-    fs13 = __toESM(require("fs"), 1);
+    fs11 = __toESM(require("fs"), 1);
     path19 = __toESM(require("path"), 1);
     crypto2 = __toESM(require("crypto"), 1);
     parseBooleanFlag3 = (value) => {
@@ -3652,12 +3620,12 @@ var init_repoFingerprint = __esm({
     };
     resolveGitDir = (gitPath) => {
       try {
-        const stat6 = fs13.statSync(gitPath);
+        const stat6 = fs11.statSync(gitPath);
         if (stat6.isDirectory()) {
           return gitPath;
         }
         if (stat6.isFile()) {
-          const content = fs13.readFileSync(gitPath, "utf8");
+          const content = fs11.readFileSync(gitPath, "utf8");
           const match = content.match(/^gitdir:\s*(.+)$/m);
           if (match) {
             const gitDir = match[1].trim();
@@ -3673,7 +3641,7 @@ var init_repoFingerprint = __esm({
       let current = path19.resolve(start);
       while (true) {
         const gitPath = path19.join(current, ".git");
-        if (fs13.existsSync(gitPath)) {
+        if (fs11.existsSync(gitPath)) {
           const gitDir = resolveGitDir(gitPath);
           if (gitDir) {
             return { gitRoot: current, gitDir };
@@ -3690,7 +3658,7 @@ var init_repoFingerprint = __esm({
     readOriginRemote = (gitDir) => {
       const configPath = path19.join(gitDir, "config");
       try {
-        const content = fs13.readFileSync(configPath, "utf8");
+        const content = fs11.readFileSync(configPath, "utf8");
         const lines = content.split(/\r?\n/);
         let inOrigin = false;
         for (const line of lines) {
@@ -3720,7 +3688,7 @@ function stripLeadingLineComments2(text) {
 }
 async function pathExists3(filePath) {
   try {
-    await fs14.access(filePath);
+    await fs12.access(filePath);
     return true;
   } catch {
     return false;
@@ -3747,7 +3715,7 @@ function getKnownJetBrainsMcpConfigLocations(homeDir, repoRoot) {
 }
 async function isZeroByteConfigFile(filePath) {
   if (!await pathExists3(filePath)) return false;
-  const stat6 = await fs14.stat(filePath);
+  const stat6 = await fs12.stat(filePath);
   return stat6.size === 0;
 }
 function stripDebugEnvVars(env2) {
@@ -3792,17 +3760,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;
@@ -3828,13 +3796,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) {
@@ -3845,7 +3813,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) {
@@ -3876,12 +3844,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() {
@@ -4106,7 +4074,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";
@@ -4173,10 +4141,10 @@ function logJetBrainsMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit JetBrains IDE and reopen this repo for MCP changes to take effect."
   );
 }
-var fs14, os5, path20, import_node_crypto5, import_node_child_process4, JETBRAINS_DEBUG_ENV_VARS;
+var fs12, os5, path20, import_node_crypto5, import_node_child_process4, JETBRAINS_DEBUG_ENV_VARS;
 var init_jetbrainsMcpConfig = __esm({
   "src/jetbrainsMcpConfig.ts"() {
-    fs14 = __toESM(require("fs/promises"), 1);
+    fs12 = __toESM(require("fs/promises"), 1);
     os5 = __toESM(require("os"), 1);
     path20 = __toESM(require("path"), 1);
     import_node_crypto5 = require("crypto");
@@ -4201,7 +4169,7 @@ function stripLeadingLineComments3(text) {
 }
 async function pathExists4(filePath) {
   try {
-    await fs15.access(filePath);
+    await fs13.access(filePath);
     return true;
   } catch {
     return false;
@@ -4261,17 +4229,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;
@@ -4297,13 +4265,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) {
@@ -4438,7 +4406,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);
   }
@@ -4517,10 +4485,10 @@ function logWindsurfMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Refresh MCP servers in Devin Desktop settings, or restart Devin Desktop, for MCP changes to take effect."
   );
 }
-var fs15, os6, path21, import_node_crypto6;
+var fs13, os6, path21, import_node_crypto6;
 var init_windsurfMcpConfig = __esm({
   "src/windsurfMcpConfig.ts"() {
-    fs15 = __toESM(require("fs/promises"), 1);
+    fs13 = __toESM(require("fs/promises"), 1);
     os6 = __toESM(require("os"), 1);
     path21 = __toESM(require("path"), 1);
     import_node_crypto6 = require("crypto");
@@ -4536,7 +4504,7 @@ var init_windsurfMcpConfig = __esm({
 // src/opencodeMcpConfig.ts
 async function pathExists5(filePath) {
   try {
-    await fs16.access(filePath);
+    await fs14.access(filePath);
     return true;
   } catch {
     return false;
@@ -4591,17 +4559,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;
@@ -4626,7 +4594,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);
 }
@@ -4711,7 +4679,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 {
@@ -4736,10 +4704,10 @@ function logOpenCodeMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit OpenCode and reopen this repo for MCP changes to take effect."
   );
 }
-var fs16, path22, import_node_crypto7, OPENCODE_CONFIG_SCHEMA_URL, OpenCodeMcpJsonParseError, OpenCodeJsoncOnlyError;
+var fs14, path22, import_node_crypto7, OPENCODE_CONFIG_SCHEMA_URL, OpenCodeMcpJsonParseError, OpenCodeJsoncOnlyError;
 var init_opencodeMcpConfig = __esm({
   "src/opencodeMcpConfig.ts"() {
-    fs16 = __toESM(require("fs/promises"), 1);
+    fs14 = __toESM(require("fs/promises"), 1);
     path22 = __toESM(require("path"), 1);
     import_node_crypto7 = require("crypto");
     init_configUtils();
@@ -4773,7 +4741,7 @@ var init_opencodeMcpConfig = __esm({
 // src/codexMcpConfig.ts
 async function pathExists6(filePath) {
   try {
-    await fs17.access(filePath);
+    await fs15.access(filePath);
     return true;
   } catch {
     return false;
@@ -5036,17 +5004,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;
@@ -5107,7 +5075,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 (memoraoneServerMatches5(current, memoraone)) {
@@ -5119,7 +5087,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 {
@@ -5144,10 +5112,10 @@ function logCodexMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Trust this project in Codex if prompted, then restart Codex."
   );
 }
-var fs17, path23, import_node_crypto8, import_smol_toml, CODEX_MCP_SERVER_NAME, CODEX_OWNED_TABLE_PREFIX, CodexMcpTomlParseError, TABLE_HEADER_RE;
+var fs15, path23, import_node_crypto8, import_smol_toml, CODEX_MCP_SERVER_NAME, CODEX_OWNED_TABLE_PREFIX, CodexMcpTomlParseError, TABLE_HEADER_RE;
 var init_codexMcpConfig = __esm({
   "src/codexMcpConfig.ts"() {
-    fs17 = __toESM(require("fs/promises"), 1);
+    fs15 = __toESM(require("fs/promises"), 1);
     path23 = __toESM(require("path"), 1);
     import_node_crypto8 = require("crypto");
     import_smol_toml = require("smol-toml");
@@ -5178,7 +5146,7 @@ function stripLeadingLineComments4(text) {
 }
 async function pathExists7(filePath) {
   try {
-    await fs18.access(filePath);
+    await fs16.access(filePath);
     return true;
   } catch {
     return false;
@@ -5217,17 +5185,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;
@@ -5252,7 +5220,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));
 }
@@ -5332,7 +5300,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 {
@@ -5357,10 +5325,10 @@ function logKiroMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Kiro and reopen this repo for MCP changes to take effect."
   );
 }
-var fs18, path24, import_node_crypto9, KiroMcpJsonParseError;
+var fs16, path24, import_node_crypto9, KiroMcpJsonParseError;
 var init_kiroMcpConfig = __esm({
   "src/kiroMcpConfig.ts"() {
-    fs18 = __toESM(require("fs/promises"), 1);
+    fs16 = __toESM(require("fs/promises"), 1);
     path24 = __toESM(require("path"), 1);
     import_node_crypto9 = require("crypto");
     init_configUtils();
@@ -5387,7 +5355,7 @@ function stripLeadingLineComments5(text) {
 }
 async function pathExists8(filePath) {
   try {
-    await fs19.access(filePath);
+    await fs17.access(filePath);
     return true;
   } catch {
     return false;
@@ -5427,17 +5395,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;
@@ -5462,7 +5430,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));
 }
@@ -5542,7 +5510,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 {
@@ -5573,10 +5541,10 @@ function logRooCodeMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Roo Code and reopen this repo for MCP changes to take effect."
   );
 }
-var fs19, path25, import_node_crypto10, RooCodeMcpJsonParseError;
+var fs17, path25, import_node_crypto10, RooCodeMcpJsonParseError;
 var init_rooCodeMcpConfig = __esm({
   "src/rooCodeMcpConfig.ts"() {
-    fs19 = __toESM(require("fs/promises"), 1);
+    fs17 = __toESM(require("fs/promises"), 1);
     path25 = __toESM(require("path"), 1);
     import_node_crypto10 = require("crypto");
     init_configUtils();
@@ -5603,7 +5571,7 @@ function stripLeadingLineComments6(text) {
 }
 async function pathExists9(filePath) {
   try {
-    await fs20.access(filePath);
+    await fs18.access(filePath);
     return true;
   } catch {
     return false;
@@ -5657,17 +5625,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;
@@ -5693,7 +5661,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));
 }
@@ -5814,7 +5782,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,
@@ -5855,10 +5823,10 @@ function logClineCliMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Cline CLI and reopen for MCP changes to take effect."
   );
 }
-var fs20, os7, path26, import_node_crypto11, CLINE_CLI_MCP_TIMEOUT_SECONDS, ClineCliMcpJsonParseError;
+var fs18, os7, path26, import_node_crypto11, CLINE_CLI_MCP_TIMEOUT_SECONDS, ClineCliMcpJsonParseError;
 var init_clineCliMcpConfig = __esm({
   "src/clineCliMcpConfig.ts"() {
-    fs20 = __toESM(require("fs/promises"), 1);
+    fs18 = __toESM(require("fs/promises"), 1);
     os7 = __toESM(require("os"), 1);
     path26 = __toESM(require("path"), 1);
     import_node_crypto11 = require("crypto");
@@ -5887,7 +5855,7 @@ function stripLeadingLineComments7(text) {
 }
 async function pathExists10(filePath) {
   try {
-    await fs21.access(filePath);
+    await fs19.access(filePath);
     return true;
   } catch {
     return false;
@@ -5937,17 +5905,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;
@@ -5973,13 +5941,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) {
@@ -6066,7 +6034,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 {
@@ -6102,10 +6070,10 @@ function logClaudeDesktopMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Claude Desktop and reopen for MCP changes to take effect."
   );
 }
-var fs21, os8, path27, import_node_crypto12, ClaudeDesktopMcpJsonParseError;
+var fs19, os8, path27, import_node_crypto12, ClaudeDesktopMcpJsonParseError;
 var init_claudeDesktopMcpConfig = __esm({
   "src/claudeDesktopMcpConfig.ts"() {
-    fs21 = __toESM(require("fs/promises"), 1);
+    fs19 = __toESM(require("fs/promises"), 1);
     os8 = __toESM(require("os"), 1);
     path27 = __toESM(require("path"), 1);
     import_node_crypto12 = require("crypto");
@@ -6133,7 +6101,7 @@ function stripLeadingLineComments8(text) {
 }
 async function pathExists11(filePath) {
   try {
-    await fs22.access(filePath);
+    await fs20.access(filePath);
     return true;
   } catch {
     return false;
@@ -6176,17 +6144,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;
@@ -6211,7 +6179,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));
 }
@@ -6291,7 +6259,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 {
@@ -6320,10 +6288,10 @@ function logZedMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Zed and reopen this repo for MCP changes to take effect."
   );
 }
-var fs22, path28, import_node_crypto13, ZedMcpJsonParseError;
+var fs20, path28, import_node_crypto13, ZedMcpJsonParseError;
 var init_zedMcpConfig = __esm({
   "src/zedMcpConfig.ts"() {
-    fs22 = __toESM(require("fs/promises"), 1);
+    fs20 = __toESM(require("fs/promises"), 1);
     path28 = __toESM(require("path"), 1);
     import_node_crypto13 = require("crypto");
     init_configUtils();
@@ -6350,7 +6318,7 @@ function stripLeadingLineComments9(text) {
 }
 async function pathExists12(filePath) {
   try {
-    await fs23.access(filePath);
+    await fs21.access(filePath);
     return true;
   } catch {
     return false;
@@ -6391,17 +6359,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;
@@ -6426,7 +6394,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));
 }
@@ -6506,7 +6474,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 {
@@ -6537,10 +6505,10 @@ function logVisualStudioMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Visual Studio and reopen this repo for MCP changes to take effect."
   );
 }
-var fs23, path29, import_node_crypto14, VisualStudioMcpJsonParseError;
+var fs21, path29, import_node_crypto14, VisualStudioMcpJsonParseError;
 var init_visualStudioMcpConfig = __esm({
   "src/visualStudioMcpConfig.ts"() {
-    fs23 = __toESM(require("fs/promises"), 1);
+    fs21 = __toESM(require("fs/promises"), 1);
     path29 = __toESM(require("path"), 1);
     import_node_crypto14 = require("crypto");
     init_configUtils();
@@ -6564,7 +6532,7 @@ var init_visualStudioMcpConfig = __esm({
 // src/continueMcpConfig.ts
 async function pathExists13(filePath) {
   try {
-    await fs24.access(filePath);
+    await fs22.access(filePath);
     return true;
   } catch {
     return false;
@@ -6631,17 +6599,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;
@@ -6736,7 +6704,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);
@@ -6761,7 +6729,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);
@@ -6795,10 +6763,10 @@ function logContinueMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Continue and reopen this repo for MCP changes to take effect."
   );
 }
-var fs24, path30, import_node_crypto15, import_yaml, ContinueMcpYamlParseError;
+var fs22, path30, import_node_crypto15, import_yaml, ContinueMcpYamlParseError;
 var init_continueMcpConfig = __esm({
   "src/continueMcpConfig.ts"() {
-    fs24 = __toESM(require("fs/promises"), 1);
+    fs22 = __toESM(require("fs/promises"), 1);
     path30 = __toESM(require("path"), 1);
     import_node_crypto15 = require("crypto");
     import_yaml = require("yaml");
@@ -6826,7 +6794,7 @@ function stripLeadingLineComments10(text) {
 }
 async function pathExists14(filePath) {
   try {
-    await fs25.access(filePath);
+    await fs23.access(filePath);
     return true;
   } catch {
     return false;
@@ -6859,17 +6827,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;
@@ -6892,13 +6860,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) {
@@ -6964,7 +6932,7 @@ 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 };
 }
 function logClineMcpCliSummary(info, dryRun, println = console.log) {
@@ -6980,11 +6948,11 @@ function logClineMcpCliSummary(info, dryRun, println = console.log) {
   if (info.npxPath) println(`[setup-ide-files] Resolved npx: ${info.npxPath}`);
   println("[setup-ide-files] Fully quit Cline and reopen this repository for MCP changes to take effect.");
 }
-var import_node_crypto16, fs25, path31, ClineMcpJsonParseError;
+var import_node_crypto16, fs23, path31, ClineMcpJsonParseError;
 var init_clineMcpConfig = __esm({
   "src/clineMcpConfig.ts"() {
     import_node_crypto16 = require("crypto");
-    fs25 = __toESM(require("fs/promises"), 1);
+    fs23 = __toESM(require("fs/promises"), 1);
     path31 = __toESM(require("path"), 1);
     init_configUtils();
     init_cursorGlobalMcpConfig();
@@ -7010,7 +6978,7 @@ function stripLeadingLineComments11(text) {
 }
 async function pathExists15(filePath) {
   try {
-    await fs26.access(filePath);
+    await fs24.access(filePath);
     return true;
   } catch {
     return false;
@@ -7051,17 +7019,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;
@@ -7086,7 +7054,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));
 }
@@ -7166,7 +7134,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 {
@@ -7197,10 +7165,10 @@ function logCopilotCliMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Copilot CLI and reopen this repo for MCP changes to take effect."
   );
 }
-var fs26, path32, import_node_crypto17, CopilotCliMcpJsonParseError;
+var fs24, path32, import_node_crypto17, CopilotCliMcpJsonParseError;
 var init_copilotCliMcpConfig = __esm({
   "src/copilotCliMcpConfig.ts"() {
-    fs26 = __toESM(require("fs/promises"), 1);
+    fs24 = __toESM(require("fs/promises"), 1);
     path32 = __toESM(require("path"), 1);
     import_node_crypto17 = require("crypto");
     init_configUtils();
@@ -7227,7 +7195,7 @@ function stripLeadingLineComments12(text) {
 }
 async function pathExists16(filePath) {
   try {
-    await fs27.access(filePath);
+    await fs25.access(filePath);
     return true;
   } catch {
     return false;
@@ -7267,17 +7235,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;
@@ -7302,7 +7270,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));
 }
@@ -7382,7 +7350,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 {
@@ -7413,10 +7381,10 @@ function logAuggieMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Augment Code / Auggie and reopen this repo for MCP changes to take effect."
   );
 }
-var fs27, path33, import_node_crypto18, AuggieMcpJsonParseError;
+var fs25, path33, import_node_crypto18, AuggieMcpJsonParseError;
 var init_auggieMcpConfig = __esm({
   "src/auggieMcpConfig.ts"() {
-    fs27 = __toESM(require("fs/promises"), 1);
+    fs25 = __toESM(require("fs/promises"), 1);
     path33 = __toESM(require("path"), 1);
     import_node_crypto18 = require("crypto");
     init_configUtils();
@@ -7443,7 +7411,7 @@ function stripLeadingLineComments13(text) {
 }
 async function pathExists17(filePath) {
   try {
-    await fs28.access(filePath);
+    await fs26.access(filePath);
     return true;
   } catch {
     return false;
@@ -7483,17 +7451,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;
@@ -7518,7 +7486,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));
 }
@@ -7598,7 +7566,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 {
@@ -7629,10 +7597,10 @@ function logGeminiCliMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Gemini CLI and reopen this repo for MCP changes to take effect."
   );
 }
-var fs28, path34, import_node_crypto19, GeminiCliMcpJsonParseError;
+var fs26, path34, import_node_crypto19, GeminiCliMcpJsonParseError;
 var init_geminiCliMcpConfig = __esm({
   "src/geminiCliMcpConfig.ts"() {
-    fs28 = __toESM(require("fs/promises"), 1);
+    fs26 = __toESM(require("fs/promises"), 1);
     path34 = __toESM(require("path"), 1);
     import_node_crypto19 = require("crypto");
     init_configUtils();
@@ -7659,7 +7627,7 @@ function stripLeadingLineComments14(text) {
 }
 async function pathExists18(filePath) {
   try {
-    await fs29.access(filePath);
+    await fs27.access(filePath);
     return true;
   } catch {
     return false;
@@ -7723,17 +7691,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;
@@ -7759,7 +7727,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));
 }
@@ -7879,7 +7847,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 {
@@ -7918,7 +7886,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);
   }
@@ -8000,11 +7968,11 @@ function logAntigravityMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Antigravity and reopen for MCP changes to take effect."
   );
 }
-var fsSync, fs29, os9, path35, import_node_crypto20, AntigravityMcpJsonParseError;
+var fsSync, fs27, os9, path35, import_node_crypto20, AntigravityMcpJsonParseError;
 var init_antigravityMcpConfig = __esm({
   "src/antigravityMcpConfig.ts"() {
     fsSync = __toESM(require("fs"), 1);
-    fs29 = __toESM(require("fs/promises"), 1);
+    fs27 = __toESM(require("fs/promises"), 1);
     os9 = __toESM(require("os"), 1);
     path35 = __toESM(require("path"), 1);
     import_node_crypto20 = require("crypto");
@@ -8029,7 +7997,7 @@ var init_antigravityMcpConfig = __esm({
 // src/gooseMcpConfig.ts
 async function pathExists19(filePath) {
   try {
-    await fs30.access(filePath);
+    await fs28.access(filePath);
     return true;
   } catch {
     return false;
@@ -8153,17 +8121,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;
@@ -8259,7 +8227,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);
@@ -8284,7 +8252,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);
@@ -8319,10 +8287,10 @@ function logGooseMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Goose and reopen for MCP changes to take effect."
   );
 }
-var fs30, os10, path36, import_node_crypto21, import_yaml2, GooseMcpYamlParseError, MEMORAONE_PACKAGE_SPEC_RE2;
+var fs28, os10, path36, import_node_crypto21, import_yaml2, GooseMcpYamlParseError, MEMORAONE_PACKAGE_SPEC_RE2;
 var init_gooseMcpConfig = __esm({
   "src/gooseMcpConfig.ts"() {
-    fs30 = __toESM(require("fs/promises"), 1);
+    fs28 = __toESM(require("fs/promises"), 1);
     os10 = __toESM(require("os"), 1);
     path36 = __toESM(require("path"), 1);
     import_node_crypto21 = require("crypto");
@@ -8352,7 +8320,7 @@ function stripLeadingLineComments15(text) {
 }
 async function pathExists20(filePath) {
   try {
-    await fs31.access(filePath);
+    await fs29.access(filePath);
     return true;
   } catch {
     return false;
@@ -8392,17 +8360,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;
@@ -8427,7 +8395,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));
 }
@@ -8507,7 +8475,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 {
@@ -8538,10 +8506,10 @@ function logJunieMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit JetBrains IDE / Junie and reopen this repo for MCP changes to take effect."
   );
 }
-var fs31, path37, import_node_crypto22, JunieMcpJsonParseError;
+var fs29, path37, import_node_crypto22, JunieMcpJsonParseError;
 var init_junieMcpConfig = __esm({
   "src/junieMcpConfig.ts"() {
-    fs31 = __toESM(require("fs/promises"), 1);
+    fs29 = __toESM(require("fs/promises"), 1);
     path37 = __toESM(require("path"), 1);
     import_node_crypto22 = require("crypto");
     init_configUtils();
@@ -8568,7 +8536,7 @@ function stripLeadingLineComments16(text) {
 }
 async function pathExists21(filePath) {
   try {
-    await fs32.access(filePath);
+    await fs30.access(filePath);
     return true;
   } catch {
     return false;
@@ -8609,17 +8577,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;
@@ -8645,7 +8613,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));
 }
@@ -8729,7 +8697,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 {
@@ -8759,10 +8727,10 @@ function logXcodeMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit Xcode / Copilot for Xcode and reopen for MCP changes to take effect."
   );
 }
-var fs32, os11, path38, import_node_crypto23, XcodeMcpJsonParseError;
+var fs30, os11, path38, import_node_crypto23, XcodeMcpJsonParseError;
 var init_xcodeMcpConfig = __esm({
   "src/xcodeMcpConfig.ts"() {
-    fs32 = __toESM(require("fs/promises"), 1);
+    fs30 = __toESM(require("fs/promises"), 1);
     os11 = __toESM(require("os"), 1);
     path38 = __toESM(require("path"), 1);
     import_node_crypto23 = require("crypto");
@@ -8790,7 +8758,7 @@ function stripLeadingLineComments17(text) {
 }
 async function pathExists22(filePath) {
   try {
-    await fs33.access(filePath);
+    await fs31.access(filePath);
     return true;
   } catch {
     return false;
@@ -8831,17 +8799,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;
@@ -8871,7 +8839,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));
 }
@@ -8955,7 +8923,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 {
@@ -8989,10 +8957,10 @@ function logCopilotJetBrainsMcpCliSummary(info, dryRun, println = console.log) {
     "[setup-ide-files] Fully quit JetBrains IDE / GitHub Copilot and reopen for MCP changes to take effect."
   );
 }
-var fs33, os12, path39, import_node_crypto24, CopilotJetBrainsMcpJsonParseError;
+var fs31, os12, path39, import_node_crypto24, CopilotJetBrainsMcpJsonParseError;
 var init_copilotJetBrainsMcpConfig = __esm({
   "src/copilotJetBrainsMcpConfig.ts"() {
-    fs33 = __toESM(require("fs/promises"), 1);
+    fs31 = __toESM(require("fs/promises"), 1);
     os12 = __toESM(require("os"), 1);
     path39 = __toESM(require("path"), 1);
     import_node_crypto24 = require("crypto");
@@ -9596,7 +9564,7 @@ function assertUnderRepoRoot(repoRoot, absPath) {
 }
 async function pathExists23(filePath) {
   try {
-    await fs34.access(filePath);
+    await fs32.access(filePath);
     return true;
   } catch {
     return false;
@@ -9693,17 +9661,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;
@@ -9723,7 +9691,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;
@@ -9755,28 +9723,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) {
@@ -9785,7 +9753,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;
@@ -11709,10 +11677,10 @@ async function cliSetupIdeFiles(argv, options = {}) {
   }
   return 0;
 }
-var fs34, os13, path40, import_node_crypto25, MANAGED_MARKER, GITIGNORE_MEMORAONE_COMMENT, GITIGNORE_MEMORAONE_ENTRY, SharedMcpJsonParseError;
+var fs32, os13, path40, import_node_crypto25, MANAGED_MARKER, GITIGNORE_MEMORAONE_COMMENT, GITIGNORE_MEMORAONE_ENTRY, SharedMcpJsonParseError;
 var init_setupIdeFiles = __esm({
   "src/setupIdeFiles.ts"() {
-    fs34 = __toESM(require("fs/promises"), 1);
+    fs32 = __toESM(require("fs/promises"), 1);
     os13 = __toESM(require("os"), 1);
     path40 = __toESM(require("path"), 1);
     import_node_crypto25 = require("crypto");
@@ -11902,7 +11870,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;
     }
@@ -11925,7 +11893,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;
     }
@@ -11960,10 +11928,10 @@ async function restoreRootLocalState(snapshot, options = {}) {
     await writeInstallationCredentials(creds, options.credentialOptions);
   }
 }
-var fs35, path41, WORKSPACE_MAP_FILENAME, FINGERPRINT_REGEX;
+var fs33, path41, WORKSPACE_MAP_FILENAME, FINGERPRINT_REGEX;
 var init_replaceRootLocalState = __esm({
   "src/localState/replaceRootLocalState.ts"() {
-    fs35 = __toESM(require("fs/promises"), 1);
+    fs33 = __toESM(require("fs/promises"), 1);
     path41 = __toESM(require("path"), 1);
     init_installationCredentials();
     init_bindingStore();
@@ -12022,9 +11990,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 {
   }
 }
@@ -12217,13 +12185,13 @@ async function runConnectRuntimeCleanup(options) {
     staleRuntimeRemains
   };
 }
-var path42, import_node_child_process6, import_node_util5, fs36, execFileAsync5, CLINE_HUB_DAEMON_MARKER;
+var path42, import_node_child_process6, import_node_util5, fs34, execFileAsync5, CLINE_HUB_DAEMON_MARKER;
 var init_connectRuntimeCleanup = __esm({
   "src/connectRuntimeCleanup.ts"() {
     path42 = __toESM(require("path"), 1);
     import_node_child_process6 = require("child_process");
     import_node_util5 = require("util");
-    fs36 = __toESM(require("fs/promises"), 1);
+    fs34 = __toESM(require("fs/promises"), 1);
     init_cleanup();
     init_bindingSidecar();
     execFileAsync5 = (0, import_node_util5.promisify)(import_node_child_process6.execFile);
@@ -12253,10 +12221,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;
@@ -12297,7 +12265,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)
@@ -12704,10 +12672,10 @@ async function cliConnect(argv, options = {}) {
     return 1;
   }
 }
-var fs37, path43, os14;
+var fs35, path43, os14;
 var init_connectCommand = __esm({
   "src/localState/connectCommand.ts"() {
-    fs37 = __toESM(require("fs/promises"), 1);
+    fs35 = __toESM(require("fs/promises"), 1);
     path43 = __toESM(require("path"), 1);
     os14 = __toESM(require("os"), 1);
     init_config();
@@ -13007,7 +12975,7 @@ function delay(ms, signal) {
 async function resolveWorkspaceRoot(workspaceRoot) {
   const resolved = path45.resolve(workspaceRoot);
   try {
-    const st = await fs38.stat(resolved);
+    const st = await fs36.stat(resolved);
     if (!st.isDirectory()) {
       return { error: "workspace-root must be a directory" };
     }
@@ -13182,10 +13150,10 @@ async function cliPluginPair(argv, options = {}) {
     }
   }
 }
-var fs38, path45, PLUGIN_PAIR_USAGE, DEFAULT_PLUGIN_PAIR_POLL_INTERVAL_MS, SECRET_OUTPUT_RE;
+var fs36, 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);
+    fs36 = __toESM(require("fs/promises"), 1);
     path45 = __toESM(require("path"), 1);
     init_pluginPairing();
     init_projectBinding();
@@ -13239,7 +13207,7 @@ function writeJson(payload, stdoutWrite) {
 async function resolveWorkspaceRoot2(workspaceRoot) {
   const resolved = path46.resolve(workspaceRoot);
   try {
-    const st = await fs39.stat(resolved);
+    const st = await fs37.stat(resolved);
     if (!st.isDirectory()) {
       return { error: "workspace-root must be a directory", workspaceRoot: resolved };
     }
@@ -13291,10 +13259,10 @@ async function cliRuntimeIdentity(argv, options = {}) {
     return 1;
   }
 }
-var fs39, path46, RUNTIME_IDENTITY_USAGE, SECRET_OUTPUT_RE2;
+var fs37, path46, RUNTIME_IDENTITY_USAGE, SECRET_OUTPUT_RE2;
 var init_runtimeIdentityCommand = __esm({
   "src/runtimeIdentityCommand.ts"() {
-    fs39 = __toESM(require("fs/promises"), 1);
+    fs37 = __toESM(require("fs/promises"), 1);
     path46 = __toESM(require("path"), 1);
     init_resolveLocalBinding();
     RUNTIME_IDENTITY_USAGE = "Usage: memoraone-mcp runtime-identity --workspace-root <path>";