agentcache 0.5.0-beta.1 → 0.5.0-beta.2

package/README.md

@@ -2,7 +2,7 @@
 
 > **Pick a coding session and continue it in another agent.**
 
-**AgentCache 0.5.0-beta.1 is a same-machine public beta.** It keeps a local,
+**AgentCache 0.5.0-beta.2 is a same-machine public beta.** It keeps a local,
 portable timeline for an explicitly selected coding session, then hands a
 bounded checkpoint to another registered agent through MCP. There is no
 Markdown handoff file to maintain and no silent choice of “latest” session.
@@ -39,14 +39,16 @@ match.
 1. Install the pinned beta and run the explicit setup step.
 
    ```bash
-   npm install -g agentcache@0.5.0-beta.1
+   npm install -g agentcache@0.5.0-beta.2
    agentcache setup
    ```
 
    Installation has no postinstall configuration hook. Setup is explicit:
    `agentcache setup` detects installed clients and adds a client-bound MCP
-   entry such as `agentcache serve --adapter codex` when the existing config is
-   unambiguous. Restart or reload clients after setup.
+   entry using the exact active Node executable and installed AgentCache CLI.
+   This prevents an IDE's bundled Node from loading a native dependency built
+   for another Node version. Rerun setup after changing Node versions, global
+   npm prefixes, or AgentCache installations, then restart or reload clients.
 
 2. Check what AgentCache actually detected and what each adapter can do.
 

package/dist/{chunk-ECMT4ANK.js → chunk-YKG6CDGT.js}

@@ -18,7 +18,7 @@ import { dirname as dirname2, isAbsolute, join as join2, resolve as resolve2 } f
 import { homedir } from "os";
 import { TextDecoder } from "util";
 import { parse as parseToml } from "smol-toml";
-import { isMap, parseDocument } from "yaml";
+import { isMap, isScalar, isSeq, parseDocument } from "yaml";
 
 // src/utils/atomic-file.ts
 import {
@@ -626,15 +626,22 @@ function isAgentCacheExecutable(value) {
     executableBasename(value) ?? ""
   );
 }
+function isPortableAbsolutePath(value) {
+  return isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || /^\\\\/.test(value);
+}
+function isRecognizedAgentCacheScript(value) {
+  if (typeof value !== "string" || !isPortableAbsolutePath(value)) return false;
+  if (isAgentCacheExecutable(value)) return true;
+  const segments = value.toLowerCase().split(/[/\\]+/).filter(Boolean);
+  return segments.length >= 3 && segments.at(-3) === "agentcache" && segments.at(-2) === "dist" && segments.at(-1) === "cli.js";
+}
 function isAgentCacheNodeWrapper(value, ide) {
-  if (!isJsonObject(value) || !["node", "node.exe"].includes(executableBasename(value.command) ?? "")) {
+  if (!isJsonObject(value) || typeof value.command !== "string" || !isPortableAbsolutePath(value.command) || !["node", "node.exe"].includes(executableBasename(value.command) ?? "")) {
     return false;
   }
   if (!Array.isArray(value.args) || value.args.length < 2) return false;
   const script = value.args[0];
-  const scriptName = executableBasename(script);
-  const isAgentCacheScript = scriptName === "agentcache" || scriptName === "agentcache.cmd" || scriptName === "agentcache.exe" || scriptName === "cli.js" && typeof script === "string" && /agentcache/i.test(script);
-  if (!isAgentCacheScript) return false;
+  if (!isRecognizedAgentCacheScript(script)) return false;
   return argsEqual(value.args.slice(1), ["serve"]) || argsEqual(value.args.slice(1), boundServeArgs(ide));
 }
 function registrationOwnership(config, ide, desired) {
@@ -649,7 +656,7 @@ function registrationOwnership(config, ide, desired) {
   if (isJsonObject(existing) && isAgentCacheExecutable(existing.command) && (argsEqual(existing.args, ["serve"]) || argsEqual(existing.args, boundServeArgs(ide)))) {
     return "owned";
   }
-  if (isVscodeExtensionIde(ide) && isAgentCacheNodeWrapper(existing, ide)) {
+  if (isAgentCacheNodeWrapper(existing, ide)) {
     return "owned";
   }
   return "ambiguous";
@@ -845,7 +852,8 @@ function unregisterMcpServer(ide) {
 }
 function isMcpServerRegistered(ide) {
   if (ide.mcpConfigFormat === "claude-settings") {
-    return isJsonMcpServerRegistered(ide, claudeServerConfig(ide));
+    const desired = claudeServerConfig(ide);
+    return desired ? isJsonMcpServerRegistered(ide, desired) : false;
   }
   if (ide.mcpConfigFormat === "mcp-json" || ide.mcpConfigFormat === "continue-dir") {
     const desired = serverConfig(ide);
@@ -859,8 +867,9 @@ function inspectMcpServerPresence(ide) {
   const obsoletePresence = inspectObsoleteJsonRegistrationPresence(ide);
   let currentPresence;
   if (ide.mcpConfigFormat === "claude-settings") {
+    const desired = claudeServerConfig(ide);
     currentPresence = combineRegistrationPresence(
-      inspectJsonMcpServerPresence(ide, claudeServerConfig(ide)),
+      desired ? inspectJsonMcpServerPresence(ide, desired) : "unknown",
       inspectClaudeSettingsPresence(claudeSettingsPath(ide))
     );
   } else if (ide.mcpConfigFormat === "mcp-json" || ide.mcpConfigFormat === "continue-dir") {
@@ -991,6 +1000,7 @@ function registerClaudeCode(ide) {
   const config = configFile.config;
   const settings = settingsFile.config;
   const desired = claudeServerConfig(ide);
+  if (!desired) return skipped("trusted AgentCache CLI entrypoint unavailable");
   if (registrationOwnership(config, ide, desired) === "ambiguous") {
     return skipped("ambiguous AgentCache registration preserved");
   }
@@ -1045,7 +1055,9 @@ function unregisterClaudeCode(ide) {
   if (!configFile || !settingsFile || !validServerMap(configFile.config.mcpServers)) return false;
   const config = configFile.config;
   const settings = settingsFile.config;
-  const ownership = registrationOwnership(config, ide, claudeServerConfig(ide));
+  const desired = claudeServerConfig(ide);
+  if (!desired) return false;
+  const ownership = registrationOwnership(config, ide, desired);
   if (ownership === "ambiguous") return false;
   if (legacyClaudeHookOwnership(settings) === "ambiguous") return false;
   const legacyOwnership = legacyLoopRegistrationOwnership(config);
@@ -1073,24 +1085,26 @@ function unregisterClaudeCode(ide) {
 function boundServeArgs(ide) {
   return ["serve", "--adapter", ide.adapterId];
 }
+function pinnedServeCommand(ide) {
+  if (!registrationCliEntrypoint) return void 0;
+  return {
+    command: process.execPath,
+    args: [registrationCliEntrypoint, ...boundServeArgs(ide)]
+  };
+}
 function claudeServerConfig(ide) {
+  const pinned = pinnedServeCommand(ide);
+  if (!pinned) return void 0;
   return {
     type: "stdio",
-    command: "agentcache",
-    args: boundServeArgs(ide),
+    ...pinned,
     env: {}
   };
 }
 function serverConfig(ide) {
-  if (isVscodeExtensionIde(ide)) {
-    if (!registrationCliEntrypoint) return void 0;
-    return {
-      command: process.execPath,
-      args: [registrationCliEntrypoint, ...boundServeArgs(ide)],
-      disabled: false
-    };
-  }
-  return { command: "agentcache", args: boundServeArgs(ide) };
+  const pinned = pinnedServeCommand(ide);
+  if (!pinned) return void 0;
+  return isVscodeExtensionIde(ide) ? { ...pinned, disabled: false } : pinned;
 }
 function isJsonMcpServerRegistered(ide, desired) {
   const config = parseJsonFileForInspection(ide.mcpConfigPath);
@@ -1225,22 +1239,28 @@ function restoreGooseTarget(target, published, original) {
   return !restore.conflict && !restore.unsupported && restore.changed;
 }
 function gooseServerConfig(ide) {
+  const pinned = pinnedServeCommand(ide);
+  if (!pinned) return void 0;
   return {
     enabled: true,
     name: GOOSE_EXTENSION_KEY,
     description: "AgentCache MCP server",
     type: "stdio",
-    cmd: "agentcache",
-    args: boundServeArgs(ide)
+    cmd: pinned.command,
+    args: pinned.args
   };
 }
-function gooseCoreMatches(value, args) {
-  return isJsonObject(value) && value.name === GOOSE_EXTENSION_KEY && value.type === "stdio" && value.cmd === "agentcache" && argsEqual(value.args, args);
+function gooseCoreMatches(value, expected) {
+  return isJsonObject(value) && value.name === GOOSE_EXTENSION_KEY && value.type === "stdio" && value.cmd === expected.cmd && argsEqual(value.args, expected.args);
 }
-function gooseOwnership(value, ide) {
+function gooseOwnership(value, ide, desired) {
   if (value === void 0) return "absent";
-  if (gooseCoreMatches(value, boundServeArgs(ide))) return "owned";
-  if (gooseCoreMatches(value, ["serve"])) return "owned";
+  if (desired && gooseCoreMatches(value, desired)) return "owned";
+  if (gooseCoreMatches(value, { cmd: "agentcache", args: boundServeArgs(ide) })) return "owned";
+  if (gooseCoreMatches(value, { cmd: "agentcache", args: ["serve"] })) return "owned";
+  if (isJsonObject(value) && value.name === GOOSE_EXTENSION_KEY && value.type === "stdio" && isAgentCacheNodeWrapper({ command: value.cmd, args: value.args }, ide)) {
+    return "owned";
+  }
   return "ambiguous";
 }
 function parseGooseDocument(content) {
@@ -1289,11 +1309,12 @@ function registerGoose(ide) {
   } catch {
     return skipped("malformed or unsupported Goose YAML config preserved");
   }
-  const ownership = gooseOwnership(existing, ide);
+  const desired = gooseServerConfig(ide);
+  if (!desired) return skipped("trusted AgentCache CLI entrypoint unavailable");
+  const ownership = gooseOwnership(existing, ide, desired);
   if (ownership === "ambiguous" || existingNode !== void 0 && !isMap(existingNode)) {
     return skipped("ambiguous AgentCache registration preserved");
   }
-  const desired = gooseServerConfig(ide);
   if (ownership === "owned" && Object.entries(desired).every(([key, value]) => {
     const existingValue = existing[key];
     return Array.isArray(value) ? argsEqual(existingValue, value) : existingValue === value;
@@ -1320,7 +1341,29 @@ function registerGoose(ide) {
     for (const [key, value] of Object.entries(desired)) {
       const existingValue = existing[key];
       const matches = Array.isArray(value) ? argsEqual(existingValue, value) : existingValue === value;
-      if (!matches) existingNode.set(key, document.createNode(value));
+      if (!matches) {
+        const currentNode = existingNode.get(key, true);
+        if (isScalar(currentNode) && !Array.isArray(value)) currentNode.value = value;
+        else {
+          const replacement = document.createNode(value);
+          if (isSeq(currentNode) && isSeq(replacement)) {
+            replacement.comment = currentNode.comment;
+            replacement.commentBefore = currentNode.commentBefore;
+            replacement.spaceBefore = currentNode.spaceBefore;
+            for (const replacementItem of replacement.items) {
+              if (!isScalar(replacementItem)) continue;
+              const previousItem = currentNode.items.find(
+                (item) => isScalar(item) && item.value === replacementItem.value
+              );
+              if (!isScalar(previousItem)) continue;
+              replacementItem.comment = previousItem.comment;
+              replacementItem.commentBefore = previousItem.commentBefore;
+              replacementItem.spaceBefore = previousItem.spaceBefore;
+            }
+          }
+          existingNode.set(key, replacement);
+        }
+      }
     }
   } else {
     const desiredNode = createGooseMap(document, desired);
@@ -1364,7 +1407,7 @@ function unregisterGoose(ide) {
   } catch {
     return false;
   }
-  if (gooseOwnership(existing, ide) !== "owned") return false;
+  if (gooseOwnership(existing, ide, gooseServerConfig(ide)) !== "owned") return false;
   extensions.delete(GOOSE_EXTENSION_KEY);
   if (!gooseTargetStillBound(target, file.expectation)) return false;
   const next = String(document);
@@ -1389,7 +1432,8 @@ function isGooseRegistered(ide) {
     const entry = extensions.get(GOOSE_EXTENSION_KEY, true);
     if (!entry || !isMap(entry)) return false;
     const value = entry.toJSON();
-    return isJsonObject(value) && value.enabled === true && gooseCoreMatches(value, boundServeArgs(ide));
+    const desired = gooseServerConfig(ide);
+    return !!desired && isJsonObject(value) && value.enabled === true && gooseCoreMatches(value, desired);
   } catch {
     return false;
   }
@@ -1409,21 +1453,25 @@ function inspectGoosePresence(ide) {
     const entry = extensions.get(GOOSE_EXTENSION_KEY, true);
     if (entry === void 0) return "absent";
     if (!isMap(entry)) return "unknown";
-    return gooseOwnership(entry.toJSON(), ide) === "owned" ? "present" : "unknown";
+    return gooseOwnership(entry.toJSON(), ide, gooseServerConfig(ide)) === "owned" ? "present" : "unknown";
   } catch {
     return "unknown";
   }
 }
-function codexBlock(ide, legacy = false) {
+function formatCodexBlock(command, args) {
   return [
     CODEX_MARKER_START,
     "[mcp_servers.agentcache]",
-    'command = "agentcache"',
-    legacy ? 'args = ["serve"]' : `args = ["serve", "--adapter", ${JSON.stringify(ide.adapterId)}]`,
+    `command = ${JSON.stringify(command)}`,
+    `args = [${args.map((value) => JSON.stringify(value)).join(", ")}]`,
     CODEX_MARKER_END,
     ""
   ].join("\n");
 }
+function codexBlock(ide) {
+  const pinned = pinnedServeCommand(ide);
+  return pinned ? formatCodexBlock(pinned.command, pinned.args) : void 0;
+}
 function maskTomlStrings(content) {
   let state = "normal";
   let masked = "";
@@ -1500,6 +1548,42 @@ function maskTomlStrings(content) {
   }
   return state === "normal" || state === "comment" ? masked : void 0;
 }
+var TOML_HEADER_SENTINEL = "__agentcache_header_sentinel_4f20c6d1__";
+function tomlHeaderSentinelPaths(value) {
+  if (!value || typeof value !== "object") return [];
+  const paths = [];
+  for (const [key, child] of Object.entries(value)) {
+    if (key === TOML_HEADER_SENTINEL && child === true) {
+      paths.push([]);
+      continue;
+    }
+    const candidates = Array.isArray(child) ? child : [child];
+    for (const candidate of candidates) {
+      for (const nestedPath of tomlHeaderSentinelPaths(candidate)) {
+        paths.push([key, ...nestedPath]);
+      }
+    }
+  }
+  return paths;
+}
+function parseTomlHeader(source) {
+  try {
+    const parsed = parseToml(`${source}
+${TOML_HEADER_SENTINEL} = true
+`);
+    const paths = tomlHeaderSentinelPaths(parsed);
+    if (paths.length !== 1 || paths[0].length === 0) return void 0;
+    return { path: paths[0], array: source.startsWith("[[") };
+  } catch {
+    return void 0;
+  }
+}
+function isOwnedCodexHeader(header) {
+  return header.path.length >= 2 && header.path[0] === "mcp_servers" && header.path[1] === "agentcache";
+}
+function isExactCodexHeader(header) {
+  return !header.array && header.path.length === 2 && isOwnedCodexHeader(header);
+}
 function scanToml(content) {
   const masked = maskTomlStrings(content);
   if (masked === void 0) return void 0;
@@ -1513,6 +1597,7 @@ function scanToml(content) {
   while (offset < content.length) {
     const newline = content.indexOf("\n", offset);
     const end = newline < 0 ? content.length : newline + 1;
+    const originalLine = content.slice(offset, end).replace(/\r?\n$/, "");
     const maskedLine = masked.slice(offset, end).replace(/\r?\n$/, "");
     const trimmed = maskedLine.trim();
     const marker = trimmed === CODEX_MARKER_START ? "start" : trimmed === CODEX_MARKER_END ? "end" : void 0;
@@ -1523,11 +1608,10 @@ function scanToml(content) {
     if (marker === "start") markerStarts.push(line);
     if (marker === "end") markerEnds.push(line);
     if (code.startsWith("[") && squareDepth === 0 && inlineTableDepth === 0) {
-      const table = code.match(/^\[([A-Za-z0-9_.-]+)\]$/);
-      const tableArray = code.match(/^\[\[([A-Za-z0-9_.-]+)\]\]$/);
-      const name = table?.[1] ?? tableArray?.[1];
-      if (!name) return void 0;
-      headers.push({ name, start: offset, bodyStart: end, end: content.length });
+      const source = (commentAt < 0 ? originalLine : originalLine.slice(0, commentAt)).trim();
+      const header = parseTomlHeader(source);
+      if (!header) return void 0;
+      headers.push({ ...header, start: offset, bodyStart: end, end: content.length });
     } else if (code) {
       const startsAtTopLevel = squareDepth === 0 && inlineTableDepth === 0;
       if (startsAtTopLevel && !code.includes("=")) return void 0;
@@ -1557,68 +1641,69 @@ function scanToml(content) {
     markerEnd: markerEnds[0]
   };
 }
-function managedCodexRange(content, scan, ide) {
+function managedCodexRange(content, scan, ide, desiredBlock) {
   if (!scan.markerStart && !scan.markerEnd) return void 0;
   if (!scan.markerStart || !scan.markerEnd) return null;
   const range = { start: scan.markerStart.start, end: scan.markerEnd.end };
   const managedContent = content.slice(range.start, range.end);
-  const current = managedContent === codexBlock(ide);
-  if (!current && managedContent !== codexBlock(ide, true)) return null;
-  const ownedHeaders = scan.headers.filter(
-    (header) => header.name === "mcp_servers.agentcache" || header.name.startsWith("mcp_servers.agentcache.")
+  const current = managedContent === desiredBlock;
+  const ownedHeaders = scan.headers.filter(isOwnedCodexHeader);
+  const headersInside = scan.headers.filter(
+    (header) => header.start > scan.markerStart.start && header.start < scan.markerEnd.start
   );
-  if (ownedHeaders.length !== 1 || ownedHeaders[0].name !== "mcp_servers.agentcache" || ownedHeaders[0].start < range.start || ownedHeaders[0].start >= range.end) {
+  if (ownedHeaders.length !== 1 || headersInside.length !== 1 || headersInside[0] !== ownedHeaders[0] || !isExactCodexHeader(ownedHeaders[0]) || ownedHeaders[0].start < range.start || ownedHeaders[0].start >= range.end) {
     return null;
   }
+  const leadingTableContent = scan.lines.some(
+    (line) => line.start >= scan.markerStart.end && line.start < ownedHeaders[0].start && line.code.length > 0
+  );
+  if (leadingTableContent) return null;
   const trailingTableContent = scan.lines.some(
     (line) => line.start >= scan.markerEnd.end && line.start < ownedHeaders[0].end && line.code.length > 0
   );
   if (trailingTableContent) return null;
+  if (!legacyCodexRange(content, scan, ide, true)) return null;
   return { ...range, current };
 }
-function legacyCodexRange(content, scan, ide) {
-  const ownedHeaders = scan.headers.filter(
-    (header2) => header2.name === "mcp_servers.agentcache" || header2.name.startsWith("mcp_servers.agentcache.")
-  );
+function legacyCodexRange(content, scan, ide, allowManagedNodeWrapper = false) {
+  const ownedHeaders = scan.headers.filter(isOwnedCodexHeader);
   if (ownedHeaders.length === 0) return void 0;
-  if (ownedHeaders.length !== 1 || ownedHeaders[0].name !== "mcp_servers.agentcache") return null;
+  if (ownedHeaders.length !== 1 || !isExactCodexHeader(ownedHeaders[0])) return null;
   const header = ownedHeaders[0];
   const bodyLines = scan.lines.filter(
     (line) => line.start >= header.bodyStart && line.start < header.end && line.code.length > 0
   );
   let hasCommand = false;
   let hasArgs = false;
-  let hasBoundArgs = false;
   let hasLegacyApproval = false;
-  let semanticCommand;
+  let semanticServer;
   try {
     const parsed = parseToml(content);
-    semanticCommand = parsed.mcp_servers?.agentcache && parsed.mcp_servers.agentcache.command;
+    const table = parsed.mcp_servers?.agentcache;
+    if (!isJsonObject(table)) return null;
+    semanticServer = { command: table.command, args: table.args };
   } catch {
     return null;
   }
-  const escapedAdapterId = ide.adapterId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const boundArgs = new RegExp(
-    `^args\\s*=\\s*\\[\\s*"serve"\\s*,\\s*"--adapter"\\s*,\\s*"${escapedAdapterId}"\\s*\\]\\s*(?:#.*)?$`
-  );
   for (const line of bodyLines) {
     const source = content.slice(line.start, line.end).trim();
     if (/^command\s*=/.test(source)) {
-      if (hasCommand || !isAgentCacheExecutable(semanticCommand)) return null;
+      if (hasCommand) return null;
       hasCommand = true;
-    } else if (/^args\s*=\s*\[\s*"serve"\s*\]\s*(?:#.*)?$/.test(source)) {
-      hasArgs = true;
-    } else if (boundArgs.test(source)) {
+    } else if (/^args\s*=/.test(source)) {
+      if (hasArgs) return null;
       hasArgs = true;
-      hasBoundArgs = true;
     } else if (/^default_tools_approval_mode\s*=\s*"auto"\s*(?:#.*)?$/.test(source)) {
       hasLegacyApproval = true;
     } else return null;
   }
-  return hasCommand && hasArgs ? {
+  const desired = pinnedServeCommand(ide);
+  const current = !!desired && serverCoreMatches(semanticServer, desired);
+  const owned = current || isAgentCacheExecutable(semanticServer.command) && (argsEqual(semanticServer.args, ["serve"]) || argsEqual(semanticServer.args, boundServeArgs(ide))) || allowManagedNodeWrapper && isAgentCacheNodeWrapper(semanticServer, ide);
+  return hasCommand && hasArgs && owned ? {
     start: header.start,
     end: header.end,
-    current: hasBoundArgs && !hasLegacyApproval
+    current: current && !hasLegacyApproval
   } : null;
 }
 function removeCodexRange(content, range) {
@@ -1627,6 +1712,8 @@ function removeCodexRange(content, range) {
   return content.slice(0, start) + content.slice(range.end);
 }
 function registerCodex(ide) {
+  const desiredBlock = codexBlock(ide);
+  if (!desiredBlock) return skipped("trusted AgentCache CLI entrypoint unavailable");
   const file = readBoundedRegistrationFile(ide.mcpConfigPath, true);
   if (!file) return skipped("malformed or ambiguous TOML config preserved");
   const original = file.content;
@@ -1635,14 +1722,14 @@ function registerCodex(ide) {
   }
   const scan = scanToml(original);
   if (!scan) return skipped("malformed or ambiguous TOML config preserved");
-  const managed = managedCodexRange(original, scan, ide);
+  const managed = managedCodexRange(original, scan, ide, desiredBlock);
   if (managed === null) return skipped("malformed or ambiguous TOML config preserved");
   if (managed?.current) {
     return atomicWriteExpectationMatches(ide.mcpConfigPath, file.expectation) ? { status: "unchanged" } : skipped("Codex config changed during registration");
   }
   const legacy = managed ?? legacyCodexRange(original, scan, ide);
   if (legacy === null) return skipped("malformed or ambiguous TOML config preserved");
-  const next = legacy ? original.slice(0, legacy.start) + codexBlock(ide) + original.slice(legacy.end) : `${original}${original.length > 0 ? "\n\n" : ""}${codexBlock(ide)}`;
+  const next = legacy ? original.slice(0, legacy.start) + desiredBlock + original.slice(legacy.end) : `${original}${original.length > 0 ? "\n\n" : ""}${desiredBlock}`;
   if (!isValidToml(next)) {
     return skipped("generated TOML would be invalid; existing config preserved");
   }
@@ -1652,13 +1739,15 @@ function registerCodex(ide) {
   );
 }
 function unregisterCodex(ide) {
+  const desiredBlock = codexBlock(ide);
+  if (!desiredBlock) return false;
   const file = readBoundedRegistrationFile(ide.mcpConfigPath);
   if (!file) return false;
   const original = file.content;
   if (!isValidToml(original)) return false;
   const scan = scanToml(original);
   if (!scan) return false;
-  const managed = managedCodexRange(original, scan, ide);
+  const managed = managedCodexRange(original, scan, ide, desiredBlock);
   if (managed === null) return false;
   const legacy = managed ? void 0 : legacyCodexRange(original, scan, ide);
   if (legacy === null) return false;
@@ -1671,13 +1760,15 @@ function unregisterCodex(ide) {
 }
 function isCodexRegistered(ide) {
   try {
+    const desiredBlock = codexBlock(ide);
+    if (!desiredBlock) return false;
     const file = readBoundedRegistrationFile(ide.mcpConfigPath);
     if (!file) return false;
     const original = file.content;
     if (!isValidToml(original)) return false;
     const scan = scanToml(original);
     if (!scan) return false;
-    const managed = managedCodexRange(original, scan, ide);
+    const managed = managedCodexRange(original, scan, ide, desiredBlock);
     if (managed === null) return false;
     if (managed) return managed.current;
     const recognized = legacyCodexRange(original, scan, ide);
@@ -1688,6 +1779,8 @@ function isCodexRegistered(ide) {
 }
 function inspectCodexPresence(ide) {
   try {
+    const desiredBlock = codexBlock(ide);
+    if (!desiredBlock) return "unknown";
     const file = readBoundedRegistrationFile(ide.mcpConfigPath, true);
     if (!file) return "unknown";
     if (!file.expectation.existed) return "absent";
@@ -1695,7 +1788,7 @@ function inspectCodexPresence(ide) {
     if (!isValidToml(original)) return "unknown";
     const scan = scanToml(original);
     if (!scan) return "unknown";
-    const managed = managedCodexRange(original, scan, ide);
+    const managed = managedCodexRange(original, scan, ide, desiredBlock);
     if (managed === null) return "unknown";
     if (managed) return "present";
     const legacy = legacyCodexRange(original, scan, ide);

package/dist/{chunk-4T3I3ACZ.js → chunk-YY7QXBG5.js}

@@ -2,7 +2,7 @@ import {
   inspectMcpServerPresence,
   registerMcpServer,
   unregisterMcpServer
-} from "./chunk-ECMT4ANK.js";
+} from "./chunk-YKG6CDGT.js";
 import {
   detectInstalledIdes
 } from "./chunk-RXGW4Q3G.js";
@@ -3343,7 +3343,8 @@ import {
   fstatSync as fstatSync2,
   lstatSync as lstatSync2,
   mkdirSync,
-  openSync as openSync2
+  openSync as openSync2,
+  unlinkSync
 } from "fs";
 import { dirname as dirname4, posix as posix2 } from "path";
 import Database from "better-sqlite3";
@@ -3717,7 +3718,8 @@ function prepareSessionDatabasePath(dbPath) {
   const directory = preparePrivateDirectory(dirname4(dbPath));
   let descriptor;
   try {
-    descriptor = openOrCreateRegularFile(dbPath);
+    const openResult = openOrCreateRegularFile(dbPath);
+    descriptor = openResult.descriptor;
     const opened = fstatSync2(descriptor);
     if (!isSafeDatabaseFile(opened)) {
       throw unsafeSessionStorage("Session database path must be a private regular file with one link");
@@ -3737,6 +3739,17 @@ function prepareSessionDatabasePath(dbPath) {
         assertPathIdentity(dbPath, opened, "Session database path changed during initialization");
         directory.verify();
       },
+      removeCreatedFile() {
+        if (closed || !openResult.created) return;
+        try {
+          const currentDescriptor = fstatSync2(descriptor);
+          if (currentDescriptor.size !== 0 || !isSafeDatabaseFile(currentDescriptor) || !sameIdentity(opened, currentDescriptor)) return;
+          assertPathIdentity(dbPath, opened, "Session database path changed during cleanup");
+          directory.verify();
+          unlinkSync(dbPath);
+        } catch {
+        }
+      },
       close() {
         if (closed) return;
         closed = true;
@@ -3911,7 +3924,7 @@ function openOrCreateRegularFile(dbPath) {
       if (!isSafeDatabaseFile(opened) || initial && !sameIdentity(initial, opened)) {
         throw unsafeSessionStorage("Session database path changed during initialization");
       }
-      return descriptor;
+      return { descriptor, created: !initial };
     } catch (error) {
       try {
         closeSync2(descriptor);
@@ -4047,7 +4060,12 @@ var SqliteSessionRepository = class {
     let database;
     try {
       if (dbPath !== ":memory:") validateSqliteSidecars(dbPath);
-      database = dbPath === ":memory:" ? new Database(dbPath) : new Database(dbPath, { fileMustExist: true });
+      try {
+        database = dbPath === ":memory:" ? new Database(dbPath) : new Database(dbPath, { fileMustExist: true });
+      } catch (error) {
+        pathGuard?.removeCreatedFile();
+        throw error;
+      }
       pathGuard?.verify();
       if (dbPath !== ":memory:") validateSqliteSidecars(dbPath);
       this.db = database;

package/dist/cli.js

@@ -12,7 +12,7 @@ import {
   resolveWorkspace,
   serializePublicResumeCapsule,
   validateReadBudget
-} from "./chunk-4T3I3ACZ.js";
+} from "./chunk-YY7QXBG5.js";
 import {
   loadOrCreateDeviceId
 } from "./chunk-XRJ6QW6N.js";
@@ -20,7 +20,7 @@ import {
   configureMcpRegistrationEntrypoint,
   inspectLegacyClaudeHookPresence,
   isMcpServerRegistered
-} from "./chunk-ECMT4ANK.js";
+} from "./chunk-YKG6CDGT.js";
 import "./chunk-RXGW4Q3G.js";
 import {
   getSessionDbPath
@@ -2495,7 +2495,7 @@ function probeSessionDatabase(path) {
 }
 program.name("agentcache").description("Same-machine cross-agent session continuity with explicit user-selected handoffs").version(PKG_VERSION);
 program.command("setup").description("Detect IDEs and register AgentCache").action(async () => {
-  const { runSetup } = await import("./setup-CXZFERQE.js");
+  const { runSetup } = await import("./setup-7JJPW3VG.js");
   await runSetup();
 });
 program.command("serve").description("Start AgentCache MCP server (spawned by IDEs automatically)").requiredOption("--adapter <id>", "Trusted adapter identity for this MCP process").action(async (options) => {

package/dist/mcp.js

@@ -7,8 +7,8 @@ import {
   redactPortableText,
   resolveWorkspace,
   serializePublicResumeCapsule
-} from "./chunk-4T3I3ACZ.js";
-import "./chunk-ECMT4ANK.js";
+} from "./chunk-YY7QXBG5.js";
+import "./chunk-YKG6CDGT.js";
 import "./chunk-RXGW4Q3G.js";
 import {
   getSessionDbPath

package/dist/{setup-CXZFERQE.js → setup-7JJPW3VG.js}

@@ -1,7 +1,7 @@
 import {
   registerClaudeHooks,
   registerMcpServer
-} from "./chunk-ECMT4ANK.js";
+} from "./chunk-YKG6CDGT.js";
 import {
   detectInstalledIdes
 } from "./chunk-RXGW4Q3G.js";

package/docs/compatibility.md

@@ -1,7 +1,7 @@
 # AgentCache beta compatibility
 
 This document describes the runtime registry shipped in AgentCache
-`0.5.0-beta.1`. The CLI remains the source of truth on an installed machine:
+`0.5.0-beta.2`. The CLI remains the source of truth on an installed machine:
 
 ```bash
 agentcache adapter list --json
@@ -69,12 +69,18 @@ unsupported for all seven adapters. In practical terms:
 
 ## Registration formats
 
-Setup writes an adapter-bound command, never a bare untrusted identity:
+Setup writes an adapter-bound launch vector, never a bare PATH-resolved
+identity:
 
 ```text
-agentcache serve --adapter <adapter-id>
+<absolute-node> <absolute-agentcache-cli> serve --adapter <adapter-id>
 ```
 
+Both executable paths are captured from the AgentCache process performing
+setup. Rerun setup after changing Node versions or version managers, changing
+the global npm prefix, or reinstalling/upgrading AgentCache, then restart the
+clients so they reload their MCP configuration.
+
 The supported configuration families are Claude Code JSON, Cursor/Windsurf/Roo
 Code MCP JSON, Continue's MCP JSON directory, Codex TOML, and Goose YAML.
 Existing files are updated atomically with a restrictive backup. Malformed or

package/docs/demo-script.md

@@ -9,7 +9,7 @@ Do not cut around an error or replace real output with a mock.
 
 ## Preflight, off camera
 
-- Install `agentcache@0.5.0-beta.1`, run `agentcache setup`, and restart Claude
+- Install `agentcache@0.5.0-beta.2`, run `agentcache setup`, and restart Claude
   Code, Codex, and Cursor.
 - Open the same small demo repository in all three clients.
 - Run the global `agentcache doctor` to verify exact adapter-bound MCP

package/docs/launch-copy.md

@@ -5,13 +5,11 @@ portable AgentCache state from provider-native session state.
 
 ## Release gate
 
-This is staged launch copy, not evidence that the release is available. The
-`0.5.0-beta.1` npm version remains unpublished and the GitHub repository remains
-private until the final human-controlled release step. Before using any copy
-below, verify that the exact npm artifact is published, its checksum matches the
-release candidate, and the GitHub repository plus beta issue form are accessible
-to the intended audience. Do not publish the package or change repository
-visibility without explicit release approval.
+The GitHub repository is public and `0.5.0-beta.1` has been published under the
+`beta` npm tag. The `0.5.0-beta.2` copy below remains staged until the corrected
+artifact and matching GitHub prerelease are published. Before using it, verify
+the exact npm artifact and checksum, the `beta` dist-tag, and the public beta
+issue form.
 
 ## One line
 
@@ -20,7 +18,7 @@ context in another registered agent on the same machine.
 
 ## Short post
 
-AgentCache `0.5.0-beta.1` is available for testing.
+AgentCache `0.5.0-beta.2` is available for testing.
 
 Pick a coding session, choose a destination agent, and continue with a bounded
 checkpoint of the goal, decisions, completed work, blockers, constraints, and
@@ -41,7 +39,7 @@ Treat that token as a temporary bearer secret.
 Install the pinned beta:
 
 ```bash
-npm install -g agentcache@0.5.0-beta.1
+npm install -g agentcache@0.5.0-beta.2
 agentcache setup
 ```
 
@@ -51,7 +49,7 @@ AgentCache beta feedback issue form.
 
 ## GitHub release summary
 
-### AgentCache 0.5.0-beta.1 — explicit cross-agent session continuity
+### AgentCache 0.5.0-beta.2 — explicit cross-agent session continuity
 
 This beta changes AgentCache's default product path from automatic knowledge
 compilation to explicit portable sessions.

package/docs/privacy.md

@@ -1,6 +1,6 @@
 # Privacy and trust boundary
 
-AgentCache `0.5.0-beta.1` is local-first and same-machine only. Its v2 database
+AgentCache `0.5.0-beta.2` is local-first and same-machine only. Its v2 database
 and coordination state live on your machine. That statement is about where
 AgentCache stores data; it is not a promise that an AI coding client or its
 model provider operates offline.

package/docs/troubleshooting.md

@@ -13,8 +13,11 @@ agentcache adapter list --json
 agentcache adapter doctor <adapter-id> --json
 ```
 
-AgentCache `0.5.0-beta.1` requires Node.js 22 or newer. After setup or a client
-upgrade, restart the client so it reloads its MCP configuration.
+AgentCache `0.5.0-beta.2` requires Node.js 22 or newer. Setup pins the exact
+active Node executable and installed AgentCache CLI into each client config.
+After changing Node versions or version managers, changing the global npm
+prefix, reinstalling/upgrading AgentCache, or upgrading a client, rerun
+`agentcache setup` and restart the client so it reloads that configuration.
 
 The global `agentcache doctor` verifies exact adapter-bound MCP registration
 commands and, after initialization, the v2 data store. On a fresh setup before
@@ -59,7 +62,7 @@ specific registration command. AgentCache does not overwrite an entry it cannot
 prove it owns.
 
 Goose uses a YAML configuration. A JSON-only diagnostic from an older
-AgentCache build may misreport it; verify you are running `0.5.0-beta.1` before
+AgentCache build may misreport it; verify you are running `0.5.0-beta.2` before
 reporting the result.
 
 ## Handoff errors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentcache",
-  "version": "0.5.0-beta.1",
+  "version": "0.5.0-beta.2",
   "description": "Same-machine cross-agent session continuity with explicit user-selected handoffs",
   "type": "module",
   "license": "MIT",