agentcache 0.4.2 → 0.5.0-beta.2

package/dist/chunk-YKG6CDGT.js

@@ -0,0 +1,1818 @@
+import {
+  resolveGooseConfigPath
+} from "./chunk-RXGW4Q3G.js";
+
+// src/utils/ide-registrar.ts
+import {
+  closeSync as closeSync2,
+  constants as fsConstants2,
+  fstatSync as fstatSync2,
+  lstatSync as lstatSync2,
+  openSync as openSync2,
+  readSync as readSync2,
+  readlinkSync,
+  realpathSync,
+  statSync
+} from "fs";
+import { dirname as dirname2, isAbsolute, join as join2, resolve as resolve2 } from "path";
+import { homedir } from "os";
+import { TextDecoder } from "util";
+import { parse as parseToml } from "smol-toml";
+import { isMap, isScalar, isSeq, parseDocument } from "yaml";
+
+// src/utils/atomic-file.ts
+import {
+  accessSync,
+  closeSync,
+  constants as fsConstants,
+  fchmodSync,
+  fstatSync,
+  fsyncSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { randomUUID } from "crypto";
+import { basename, dirname, join, resolve } from "path";
+function missingPath(error) {
+  return error?.code === "ENOENT";
+}
+function sameFileIdentity(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function removeIfPresent(path) {
+  try {
+    unlinkSync(path);
+  } catch (error) {
+    if (!missingPath(error)) throw error;
+  }
+}
+function safeDirectory(path) {
+  try {
+    const metadata = lstatSync(path);
+    if (metadata.isSymbolicLink() || !metadata.isDirectory()) return void 0;
+    return { path, identity: { dev: metadata.dev, ino: metadata.ino } };
+  } catch {
+    return void 0;
+  }
+}
+function currentUserControlsDirectory(path, metadata) {
+  const root = dirname(path) === path;
+  if (root) return false;
+  const uid = process.getuid?.();
+  if (uid !== void 0 && (uid === 0 || metadata.uid === uid)) return true;
+  try {
+    accessSync(path, fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function inspectSafeDirectoryChain(path, createMissing) {
+  const pending = [];
+  const chain = [];
+  let cursor = resolve(path);
+  let protectedDepth = 0;
+  while (true) {
+    let metadata;
+    try {
+      metadata = lstatSync(cursor);
+    } catch (error) {
+      if (!missingPath(error)) return void 0;
+      pending.push(cursor);
+      const ancestor2 = dirname(cursor);
+      if (ancestor2 === cursor) return void 0;
+      cursor = ancestor2;
+      continue;
+    }
+    if (metadata.isSymbolicLink() || !metadata.isDirectory()) return void 0;
+    chain.push({ path: cursor, identity: { dev: metadata.dev, ino: metadata.ino } });
+    protectedDepth = currentUserControlsDirectory(cursor, metadata) ? 0 : protectedDepth + 1;
+    const ancestor = dirname(cursor);
+    if (ancestor === cursor || protectedDepth >= 2) break;
+    cursor = ancestor;
+  }
+  if (!createMissing) return chain;
+  for (const missingDirectory of pending.reverse()) {
+    if (!directoryChainMatches(chain)) return void 0;
+    try {
+      mkdirSync(missingDirectory, { mode: 448 });
+    } catch (error) {
+      if (error?.code !== "EEXIST") return void 0;
+    }
+    const created = safeDirectory(missingDirectory);
+    if (!created || !directoryChainMatches(chain)) return void 0;
+    chain.push(created);
+  }
+  return chain;
+}
+function atomicWritePathIsSafe(filePath) {
+  return inspectSafeDirectoryChain(dirname(resolve(filePath)), false) !== void 0;
+}
+function directoryChainMatches(chain) {
+  return chain.every(({ path, identity }) => {
+    const current = safeDirectory(path);
+    return !!current && sameFileIdentity(current.identity, identity);
+  });
+}
+function atomicWriteExpectationMatches(filePath, expected) {
+  if (!expected.existed) {
+    try {
+      lstatSync(filePath);
+      return false;
+    } catch (error) {
+      return missingPath(error);
+    }
+  }
+  const openFlags = fsConstants.O_RDONLY | (typeof fsConstants.O_NONBLOCK === "number" ? fsConstants.O_NONBLOCK : 0) | (typeof fsConstants.O_NOFOLLOW === "number" ? fsConstants.O_NOFOLLOW : 0);
+  let descriptor;
+  try {
+    descriptor = openSync(filePath, openFlags);
+    const opened = fstatSync(descriptor);
+    const pathAtOpen = lstatSync(filePath);
+    if (!opened.isFile() || opened.size !== expected.contents.length || !sameFileIdentity(opened, expected.identity) || pathAtOpen.isSymbolicLink() || !pathAtOpen.isFile() || !sameFileIdentity(pathAtOpen, expected.identity)) {
+      return false;
+    }
+    const actual = Buffer.alloc(expected.contents.length);
+    let length = 0;
+    while (length < actual.length) {
+      const read = readSync(descriptor, actual, length, actual.length - length, length);
+      if (read === 0) break;
+      length += read;
+    }
+    const completed = fstatSync(descriptor);
+    const finalPath = lstatSync(filePath);
+    return length === expected.contents.length && actual.equals(expected.contents) && completed.isFile() && completed.size === expected.contents.length && sameFileIdentity(completed, expected.identity) && finalPath.isFile() && !finalPath.isSymbolicLink() && sameFileIdentity(finalPath, expected.identity);
+  } catch {
+    return false;
+  } finally {
+    if (descriptor !== void 0) closeSync(descriptor);
+  }
+}
+function syncDirectory(path) {
+  let fd;
+  try {
+    fd = openSync(path, "r");
+    fsyncSync(fd);
+  } catch {
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
+}
+function writeRestrictiveFile(path, contents) {
+  const fd = openSync(path, "wx", 384);
+  let failure;
+  try {
+    fchmodSync(fd, 384);
+    writeFileSync(fd, contents);
+    fsyncSync(fd);
+  } catch (error) {
+    failure = error;
+  } finally {
+    try {
+      closeSync(fd);
+    } catch (error) {
+      failure ??= error;
+    }
+  }
+  if (failure !== void 0) {
+    removeIfPresent(path);
+    throw failure;
+  }
+}
+function atomicOperationUnsupported(error) {
+  const code = error?.code;
+  return code === "ENOTSUP" || code === "EOPNOTSUPP" || code === "ENOSYS" || code === "EXDEV" || code === "EPERM" || code === "EACCES" || code === "EROFS";
+}
+function replacementConflict(error) {
+  const code = error?.code;
+  return code === "EEXIST" || code === "EISDIR" || code === "ENOTDIR" || code === "ENOTEMPTY" || code === "ENOENT";
+}
+function publishNoReplace(sourcePath, targetPath) {
+  try {
+    linkSync(sourcePath, targetPath);
+    return "published";
+  } catch (error) {
+    if (error?.code === "EEXIST") return "conflict";
+    if (atomicOperationUnsupported(error)) return "unsupported";
+    throw error;
+  }
+}
+function atomicWriteFileSync(filePath, contents, expected) {
+  const targetPath = resolve(filePath);
+  const next = Buffer.isBuffer(contents) ? contents : Buffer.from(contents, "utf8");
+  const parent = dirname(targetPath);
+  const directoryChain = inspectSafeDirectoryChain(parent, true);
+  if (!directoryChain) return { changed: false, conflict: true };
+  if (!atomicWriteExpectationMatches(targetPath, expected)) {
+    return { changed: false, conflict: true };
+  }
+  if (expected.existed && expected.contents.equals(next)) return { changed: false };
+  let backupPath;
+  const temporaryPath = join(
+    parent,
+    `.${basename(targetPath)}.agentcache-${process.pid}-${randomUUID()}.tmp`
+  );
+  try {
+    if (!directoryChainMatches(directoryChain)) {
+      return { changed: false, conflict: true };
+    }
+    writeRestrictiveFile(temporaryPath, next);
+    if (!directoryChainMatches(directoryChain) || !atomicWriteExpectationMatches(targetPath, expected)) {
+      removeIfPresent(temporaryPath);
+      return { changed: false, conflict: true };
+    }
+    if (expected.existed) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      backupPath = `${targetPath}.agentcache-backup-${timestamp}-${randomUUID()}`;
+      writeRestrictiveFile(backupPath, expected.contents);
+      syncDirectory(parent);
+      if (!directoryChainMatches(directoryChain) || !atomicWriteExpectationMatches(targetPath, expected)) {
+        removeIfPresent(temporaryPath);
+        removeIfPresent(backupPath);
+        return { changed: false, conflict: true };
+      }
+    }
+    if (!directoryChainMatches(directoryChain) || !atomicWriteExpectationMatches(targetPath, expected)) {
+      removeIfPresent(temporaryPath);
+      if (backupPath) removeIfPresent(backupPath);
+      return { changed: false, conflict: true };
+    }
+    if (expected.existed) {
+      try {
+        renameSync(temporaryPath, targetPath);
+      } catch (error) {
+        removeIfPresent(temporaryPath);
+        if (backupPath) removeIfPresent(backupPath);
+        if (!atomicWriteExpectationMatches(targetPath, expected)) {
+          return { changed: false, conflict: true };
+        }
+        if (atomicOperationUnsupported(error)) {
+          return { changed: false, unsupported: true };
+        }
+        if (replacementConflict(error)) {
+          return { changed: false, conflict: true };
+        }
+        throw error;
+      }
+    } else {
+      const publication = publishNoReplace(temporaryPath, targetPath);
+      if (publication !== "published") {
+        removeIfPresent(temporaryPath);
+        return publication === "unsupported" ? { changed: false, unsupported: true } : { changed: false, conflict: true };
+      }
+      removeIfPresent(temporaryPath);
+    }
+    syncDirectory(parent);
+  } catch (error) {
+    removeIfPresent(temporaryPath);
+    if (backupPath) removeIfPresent(backupPath);
+    if (atomicOperationUnsupported(error)) {
+      return { changed: false, unsupported: true };
+    }
+    throw error;
+  }
+  return { changed: true, backupPath };
+}
+function atomicRemoveFileSync(filePath, expected) {
+  const targetPath = resolve(filePath);
+  const parent = dirname(targetPath);
+  const directoryChain = inspectSafeDirectoryChain(parent, false);
+  if (!directoryChain || !directoryChainMatches(directoryChain) || !atomicWriteExpectationMatches(targetPath, expected)) {
+    return { changed: false, conflict: true };
+  }
+  try {
+    if (!directoryChainMatches(directoryChain) || !atomicWriteExpectationMatches(targetPath, expected)) {
+      return { changed: false, conflict: true };
+    }
+    unlinkSync(targetPath);
+    syncDirectory(parent);
+    return { changed: true };
+  } catch (error) {
+    if (atomicOperationUnsupported(error)) return { changed: false, unsupported: true };
+    if (replacementConflict(error)) return { changed: false, conflict: true };
+    throw error;
+  }
+}
+
+// src/utils/ide-registrar.ts
+var CODEX_MARKER_START = "# >>> AgentCache managed MCP server >>>";
+var CODEX_MARKER_END = "# <<< AgentCache managed MCP server <<<";
+var MAX_REGISTRATION_CONFIG_BYTES = 1024 * 1024;
+var FATAL_UTF8_DECODER = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+var JSON_NUMBER_TOKEN = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+var registrationCliEntrypoint;
+function configureMcpRegistrationEntrypoint(entrypoint) {
+  if (!isAbsolute(entrypoint)) {
+    throw new Error("AgentCache registration CLI entrypoint must be absolute");
+  }
+  const resolved = realpathSync(entrypoint);
+  if (!statSync(resolved).isFile()) {
+    throw new Error("AgentCache registration CLI entrypoint must be a file");
+  }
+  registrationCliEntrypoint = resolved;
+}
+function isVscodeExtensionIde(ide) {
+  return ide.adapterId === "roo-code" || ide.adapterId === "continue";
+}
+function sameFileIdentity2(left, right) {
+  return left.dev === right.dev && left.ino === right.ino;
+}
+function missingPath2(error) {
+  return error?.code === "ENOENT";
+}
+function pathIsStillMissing(path, openError) {
+  if (!missingPath2(openError)) return false;
+  try {
+    lstatSync2(path);
+    return false;
+  } catch (error) {
+    return missingPath2(error);
+  }
+}
+function readBoundedRegistrationFile(path, allowMissing = false) {
+  if (!atomicWritePathIsSafe(path)) return void 0;
+  const openFlags = fsConstants2.O_RDONLY | (typeof fsConstants2.O_NONBLOCK === "number" ? fsConstants2.O_NONBLOCK : 0) | (typeof fsConstants2.O_NOFOLLOW === "number" ? fsConstants2.O_NOFOLLOW : 0);
+  let descriptor;
+  try {
+    descriptor = openSync2(path, openFlags);
+    const opened = fstatSync2(descriptor);
+    if (!opened.isFile() || opened.size > MAX_REGISTRATION_CONFIG_BYTES) return void 0;
+    const pathAtOpen = lstatSync2(path);
+    if (pathAtOpen.isSymbolicLink() || !pathAtOpen.isFile() || !sameFileIdentity2(opened, pathAtOpen)) {
+      return void 0;
+    }
+    const bytes = Buffer.alloc(MAX_REGISTRATION_CONFIG_BYTES + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const read = readSync2(descriptor, bytes, length, bytes.length - length, length);
+      if (read === 0) break;
+      length += read;
+    }
+    if (length > MAX_REGISTRATION_CONFIG_BYTES) return void 0;
+    const completed = fstatSync2(descriptor);
+    const finalPath = lstatSync2(path);
+    if (!completed.isFile() || completed.size !== opened.size || completed.mtimeMs !== opened.mtimeMs || completed.ctimeMs !== opened.ctimeMs || !sameFileIdentity2(opened, completed) || finalPath.isSymbolicLink() || !finalPath.isFile() || !sameFileIdentity2(opened, finalPath)) {
+      return void 0;
+    }
+    const contents = Buffer.from(bytes.subarray(0, length));
+    const content = FATAL_UTF8_DECODER.decode(contents);
+    return {
+      content,
+      expectation: {
+        existed: true,
+        contents,
+        identity: { dev: opened.dev, ino: opened.ino }
+      }
+    };
+  } catch (error) {
+    if (allowMissing && pathIsStillMissing(path, error)) {
+      return { content: "", expectation: { existed: false } };
+    }
+    return void 0;
+  } finally {
+    if (descriptor !== void 0) {
+      try {
+        closeSync2(descriptor);
+      } catch {
+      }
+    }
+  }
+}
+function parseJsonFile(path) {
+  const file = readBoundedRegistrationFile(path, true);
+  if (!file) return void 0;
+  if (!file.expectation.existed) return { config: {}, file };
+  if (hasLossyJsonNumber(file.content) || jsonHasDuplicateKeys(file.content) !== false) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(file.content);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    return { config: parsed, file };
+  } catch {
+    return void 0;
+  }
+}
+function normalizeJsonNumber(token) {
+  const match = token.match(
+    /^(-?)(0|[1-9]\d*)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/
+  );
+  if (!match) return void 0;
+  const fraction = match[3] ?? "";
+  let digits = `${match[2]}${fraction}`.replace(/^0+/, "");
+  if (digits.length === 0) return { negative: false, digits: "0", exponent: 0 };
+  const explicitExponent = Number(match[4] ?? "0");
+  if (!Number.isSafeInteger(explicitExponent)) return void 0;
+  let exponent = explicitExponent - fraction.length;
+  while (digits.endsWith("0")) {
+    digits = digits.slice(0, -1);
+    exponent += 1;
+  }
+  return { negative: match[1] === "-", digits, exponent };
+}
+function sameNormalizedJsonNumber(left, right) {
+  const normalizedLeft = normalizeJsonNumber(left);
+  const normalizedRight = normalizeJsonNumber(right);
+  return !!normalizedLeft && !!normalizedRight && normalizedLeft.negative === normalizedRight.negative && normalizedLeft.digits === normalizedRight.digits && normalizedLeft.exponent === normalizedRight.exponent;
+}
+function jsonNumberTokenAt(content, index) {
+  JSON_NUMBER_TOKEN.lastIndex = index;
+  return JSON_NUMBER_TOKEN.exec(content)?.[0];
+}
+function hasLossyJsonNumber(content) {
+  let inString = false;
+  let escaped = false;
+  for (let index = 0; index < content.length; index += 1) {
+    const character = content[index];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') inString = false;
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      continue;
+    }
+    if (character !== "-" && (character < "0" || character > "9")) continue;
+    const token = jsonNumberTokenAt(content, index);
+    if (!token) continue;
+    const value = Number(token);
+    if (!Number.isFinite(value) || Object.is(value, -0) || !sameNormalizedJsonNumber(token, value.toString())) {
+      return true;
+    }
+    index += token.length - 1;
+  }
+  return false;
+}
+function jsonHasDuplicateKeys(content) {
+  let index = 0;
+  let duplicate = false;
+  const skipWhitespace = () => {
+    while (content[index] === " " || content[index] === "	" || content[index] === "\r" || content[index] === "\n") {
+      index += 1;
+    }
+  };
+  const parseStringToken = () => {
+    if (content[index] !== '"') return void 0;
+    const start = index;
+    index += 1;
+    while (index < content.length) {
+      const character = content[index];
+      if (character === '"') {
+        index += 1;
+        try {
+          const decoded = JSON.parse(content.slice(start, index));
+          return typeof decoded === "string" ? decoded : void 0;
+        } catch {
+          return void 0;
+        }
+      }
+      if (character.charCodeAt(0) < 32) return void 0;
+      if (character === "\\") {
+        index += 1;
+        const escape = content[index];
+        if (escape === "u") {
+          if (!/^[0-9a-fA-F]{4}$/.test(content.slice(index + 1, index + 5))) {
+            return void 0;
+          }
+          index += 5;
+          continue;
+        }
+        if (!escape || !'"\\/bfnrt'.includes(escape)) return void 0;
+      }
+      index += 1;
+    }
+    return void 0;
+  };
+  const parseNumberToken = () => {
+    const token = jsonNumberTokenAt(content, index);
+    if (!token) return false;
+    index += token.length;
+    return true;
+  };
+  const parseValue = () => {
+    skipWhitespace();
+    if (content[index] === "{") return parseObject();
+    if (content[index] === "[") return parseArray();
+    if (content[index] === '"') return parseStringToken() !== void 0;
+    for (const literal of ["true", "false", "null"]) {
+      if (content.startsWith(literal, index)) {
+        index += literal.length;
+        return true;
+      }
+    }
+    return parseNumberToken();
+  };
+  const parseObject = () => {
+    index += 1;
+    skipWhitespace();
+    if (content[index] === "}") {
+      index += 1;
+      return true;
+    }
+    const keys = /* @__PURE__ */ new Set();
+    while (index < content.length) {
+      skipWhitespace();
+      const key = parseStringToken();
+      if (key === void 0) return false;
+      if (keys.has(key)) duplicate = true;
+      keys.add(key);
+      skipWhitespace();
+      if (content[index] !== ":") return false;
+      index += 1;
+      if (!parseValue()) return false;
+      skipWhitespace();
+      if (content[index] === "}") {
+        index += 1;
+        return true;
+      }
+      if (content[index] !== ",") return false;
+      index += 1;
+    }
+    return false;
+  };
+  const parseArray = () => {
+    index += 1;
+    skipWhitespace();
+    if (content[index] === "]") {
+      index += 1;
+      return true;
+    }
+    while (index < content.length) {
+      if (!parseValue()) return false;
+      skipWhitespace();
+      if (content[index] === "]") {
+        index += 1;
+        return true;
+      }
+      if (content[index] !== ",") return false;
+      index += 1;
+    }
+    return false;
+  };
+  try {
+    if (!parseValue()) return void 0;
+    skipWhitespace();
+    return index === content.length ? duplicate : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseJsonFileForInspection(path) {
+  const file = readBoundedRegistrationFile(path);
+  if (!file) return void 0;
+  if (hasLossyJsonNumber(file.content) || jsonHasDuplicateKeys(file.content) !== false) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(file.content);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function writeJson(path, value, expectation) {
+  return atomicWriteFileSync(path, jsonFileContents(value), expectation);
+}
+function jsonFileContents(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function registrationResult(changed) {
+  return { status: changed ? "registered" : "unchanged" };
+}
+function skipped(reason) {
+  return { status: "skipped", reason };
+}
+function registrationWriteResult(result, conflictReason, unsupportedReason = "safe atomic config publication unsupported") {
+  if (result.conflict) return skipped(conflictReason);
+  if (result.unsupported) return skipped(unsupportedReason);
+  return registrationResult(result.changed);
+}
+function isValidToml(content) {
+  try {
+    parseToml(content);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validServerMap(value) {
+  return value === void 0 || !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isJsonObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function argsEqual(value, expected) {
+  return Array.isArray(value) && value.length === expected.length && value.every((item, index) => item === expected[index]);
+}
+function serverCoreMatches(value, expected) {
+  return isJsonObject(value) && value.command === expected.command && argsEqual(value.args, expected.args);
+}
+function executableBasename(value) {
+  if (typeof value !== "string") return void 0;
+  return value.trim().split(/[/\\]/).pop()?.toLowerCase();
+}
+function isAgentCacheExecutable(value) {
+  return ["agentcache", "agentcache.cmd", "agentcache.exe"].includes(
+    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) || 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];
+  if (!isRecognizedAgentCacheScript(script)) return false;
+  return argsEqual(value.args.slice(1), ["serve"]) || argsEqual(value.args.slice(1), boundServeArgs(ide));
+}
+function registrationOwnership(config, ide, desired) {
+  if (!config.mcpServers || !Object.hasOwn(config.mcpServers, "agentcache")) {
+    return "absent";
+  }
+  const existing = config.mcpServers.agentcache;
+  if (serverCoreMatches(existing, desired)) return "owned";
+  if (serverCoreMatches(existing, { command: "agentcache", args: ["serve"] })) {
+    return "owned";
+  }
+  if (isJsonObject(existing) && isAgentCacheExecutable(existing.command) && (argsEqual(existing.args, ["serve"]) || argsEqual(existing.args, boundServeArgs(ide)))) {
+    return "owned";
+  }
+  if (isAgentCacheNodeWrapper(existing, ide)) {
+    return "owned";
+  }
+  return "ambiguous";
+}
+function legacyLoopRegistrationOwnership(config) {
+  const servers = config.mcpServers;
+  if (!servers || !isJsonObject(servers) || !Object.hasOwn(servers, "loop")) {
+    return "absent";
+  }
+  const existing = servers.loop;
+  if (isJsonObject(existing) && ["loop-eng", "loop-eng.cmd", "loop-eng.exe"].includes(
+    executableBasename(existing.command) ?? ""
+  ) && argsEqual(existing.args, ["serve"])) {
+    return "owned";
+  }
+  return "ambiguous";
+}
+function legacyClaudeSettingsRegistrationOwnership(settings, key) {
+  const servers = settings.mcpServers;
+  if (!servers || !isJsonObject(servers) || !Object.hasOwn(servers, key)) {
+    return "absent";
+  }
+  const existing = servers[key];
+  if (!isJsonObject(existing) || !argsEqual(existing.args, ["serve"])) {
+    return "ambiguous";
+  }
+  if (key === "loop") {
+    return ["loop-eng", "loop-eng.cmd", "loop-eng.exe"].includes(
+      executableBasename(existing.command) ?? ""
+    ) ? "owned" : "ambiguous";
+  }
+  return isAgentCacheExecutable(existing.command) ? "owned" : "ambiguous";
+}
+var RELEASED_LEGACY_HOOKS = Object.freeze({
+  Stop: "compile-session",
+  SessionStart: "discover",
+  PreToolUse: "enforce"
+});
+function releasedLegacyHookSubcommand(command) {
+  if (typeof command !== "string") return void 0;
+  const value = command.trim();
+  const parts = value.split(/[ \t]+/);
+  if (parts.length !== 2) return void 0;
+  const executable = executableBasename(parts[0]);
+  const subcommand = parts[1];
+  if (![
+    "agentcache",
+    "agentcache.cmd",
+    "agentcache.exe",
+    "loop-eng",
+    "loop-eng.cmd",
+    "loop-eng.exe"
+  ].includes(executable ?? "")) return void 0;
+  return ["compile-session", "discover", "enforce"].includes(subcommand) ? subcommand : void 0;
+}
+function isReleasedLegacyHookEntry(event, entry) {
+  const expectedSubcommand = RELEASED_LEGACY_HOOKS[event];
+  if (!expectedSubcommand || !isJsonObject(entry)) return false;
+  if (Object.keys(entry).sort().join("\0") !== ["hooks", "matcher"].join("\0")) return false;
+  if (entry.matcher !== "" || !Array.isArray(entry.hooks) || entry.hooks.length !== 1) return false;
+  const hook = entry.hooks[0];
+  if (!isJsonObject(hook)) return false;
+  if (Object.keys(hook).sort().join("\0") !== ["command", "type"].join("\0")) return false;
+  return hook.type === "command" && releasedLegacyHookSubcommand(hook.command) === expectedSubcommand;
+}
+function legacyClaudeHookOwnership(settings) {
+  if (!isJsonObject(settings)) return "ambiguous";
+  const hooks = settings.hooks;
+  if (hooks === void 0) return "absent";
+  if (!isJsonObject(hooks)) return "ambiguous";
+  let owned = false;
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) return "ambiguous";
+    for (const entry of entries) {
+      if (!isJsonObject(entry)) return "ambiguous";
+      if (entry.hooks === void 0) continue;
+      if (!Array.isArray(entry.hooks)) return "ambiguous";
+      for (const hook of entry.hooks) {
+        if (!isJsonObject(hook)) return "ambiguous";
+      }
+      if (isReleasedLegacyHookEntry(event, entry)) {
+        owned = true;
+        continue;
+      }
+      if (entry.hooks.some((hook) => releasedLegacyHookSubcommand(hook.command) !== void 0)) {
+        return "ambiguous";
+      }
+    }
+  }
+  return owned ? "owned" : "absent";
+}
+function inspectLegacyClaudeHookPresence(settings) {
+  const ownership = legacyClaudeHookOwnership(settings);
+  return ownership === "owned" ? "present" : ownership === "absent" ? "absent" : "unknown";
+}
+function removeAgentCacheHooks(settings) {
+  if (!settings.hooks || typeof settings.hooks !== "object" || Array.isArray(settings.hooks)) {
+    return false;
+  }
+  if (legacyClaudeHookOwnership(settings) === "ambiguous") return false;
+  let changed = false;
+  for (const [event, entriesValue] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(entriesValue)) continue;
+    const entries = entriesValue.filter((entry) => {
+      if (!isReleasedLegacyHookEntry(event, entry)) return true;
+      changed = true;
+      return false;
+    });
+    if (entries.length > 0) settings.hooks[event] = entries;
+    else delete settings.hooks[event];
+  }
+  if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  return changed;
+}
+function removeAgentCachePermissions(settings) {
+  const permissions = settings.permissions;
+  if (!permissions || typeof permissions !== "object" || Array.isArray(permissions)) return false;
+  if (!Array.isArray(permissions.allow)) return false;
+  const filtered = permissions.allow.filter(
+    (permission) => typeof permission !== "string" || !permission.startsWith("mcp__agentcache__")
+  );
+  if (filtered.length === permissions.allow.length) return false;
+  permissions.allow = filtered;
+  return true;
+}
+function removeLegacyClaudeMcpServers(settings) {
+  const servers = settings.mcpServers;
+  if (!isJsonObject(servers)) return false;
+  let changed = false;
+  for (const key of ["loop", "agentcache"]) {
+    if (legacyClaudeSettingsRegistrationOwnership(settings, key) !== "owned") continue;
+    delete servers[key];
+    changed = true;
+  }
+  if (Object.keys(servers).length === 0) delete settings.mcpServers;
+  return changed;
+}
+function hasLegacyClaudeSettings(settings) {
+  const permissions = settings.permissions;
+  const permissionsPresent = permissions !== void 0 && (!isJsonObject(permissions) || permissions.allow !== void 0 && (!Array.isArray(permissions.allow) || permissions.allow.some(
+    (permission) => typeof permission === "string" && permission.startsWith("mcp__agentcache__")
+  )));
+  const hooksPresent = legacyClaudeHookOwnership(settings) !== "absent";
+  const servers = settings.mcpServers;
+  const registrationsPresent = servers !== void 0 && (!isJsonObject(servers) || ["loop", "agentcache"].some(
+    (key) => legacyClaudeSettingsRegistrationOwnership(settings, key) !== "absent"
+  ));
+  return permissionsPresent || hooksPresent || registrationsPresent;
+}
+function restorePublishedFile(path, publishedContents, original) {
+  const published = readBoundedRegistrationFile(path);
+  if (!published?.expectation.existed || !published.expectation.contents.equals(publishedContents)) {
+    return false;
+  }
+  const restore = original.existed ? atomicWriteFileSync(path, original.contents, published.expectation) : atomicRemoveFileSync(path, published.expectation);
+  return !restore.conflict && !restore.unsupported && restore.changed;
+}
+function claudeSettingsPath(ide) {
+  const home = ide ? dirname2(ide.mcpConfigPath) : homedir();
+  return join2(home, ".claude", "settings.json");
+}
+function registerMcpServer(ide, options = {}) {
+  const obsolete = cleanOneObsoleteJsonRegistration(ide);
+  if (obsolete === "unknown") {
+    return skipped("Ambiguous obsolete AgentCache registration preserved");
+  }
+  if (obsolete === "cleaned") {
+    return skipped("Obsolete AgentCache registration cleaned; run registration again");
+  }
+  const mayInitializeGoose = options.allowUndetectedGoose === true && ide.adapterId === "goose" && ide.mcpConfigFormat === "goose-yaml";
+  if (!ide.detected && !mayInitializeGoose) return skipped("IDE not detected");
+  if (!ide.detected && ide.mcpConfigPath !== resolveGooseConfigPath()) {
+    return skipped("unsafe Goose config path preserved");
+  }
+  if (ide.mcpConfigFormat === "claude-settings") return registerClaudeCode(ide);
+  if (ide.mcpConfigFormat === "mcp-json") return registerMcpJson(ide);
+  if (ide.mcpConfigFormat === "continue-dir") return registerContinue(ide);
+  if (ide.mcpConfigFormat === "codex-toml") return registerCodex(ide);
+  if (ide.mcpConfigFormat === "goose-yaml") return registerGoose(ide);
+  return skipped("unsupported configuration format");
+}
+function unregisterMcpServer(ide) {
+  const obsolete = cleanOneObsoleteJsonRegistration(ide);
+  if (obsolete === "unknown") return false;
+  if (obsolete === "cleaned") return true;
+  if (ide.mcpConfigFormat === "claude-settings") return unregisterClaudeCode(ide);
+  if (ide.mcpConfigFormat === "mcp-json" || ide.mcpConfigFormat === "continue-dir") {
+    return unregisterJson(ide);
+  }
+  if (ide.mcpConfigFormat === "codex-toml") return unregisterCodex(ide);
+  if (ide.mcpConfigFormat === "goose-yaml") return unregisterGoose(ide);
+  return false;
+}
+function isMcpServerRegistered(ide) {
+  if (ide.mcpConfigFormat === "claude-settings") {
+    const desired = claudeServerConfig(ide);
+    return desired ? isJsonMcpServerRegistered(ide, desired) : false;
+  }
+  if (ide.mcpConfigFormat === "mcp-json" || ide.mcpConfigFormat === "continue-dir") {
+    const desired = serverConfig(ide);
+    return desired ? isJsonMcpServerRegistered(ide, desired) : false;
+  }
+  if (ide.mcpConfigFormat === "codex-toml") return isCodexRegistered(ide);
+  if (ide.mcpConfigFormat === "goose-yaml") return isGooseRegistered(ide);
+  return false;
+}
+function inspectMcpServerPresence(ide) {
+  const obsoletePresence = inspectObsoleteJsonRegistrationPresence(ide);
+  let currentPresence;
+  if (ide.mcpConfigFormat === "claude-settings") {
+    const desired = claudeServerConfig(ide);
+    currentPresence = combineRegistrationPresence(
+      desired ? inspectJsonMcpServerPresence(ide, desired) : "unknown",
+      inspectClaudeSettingsPresence(claudeSettingsPath(ide))
+    );
+  } else if (ide.mcpConfigFormat === "mcp-json" || ide.mcpConfigFormat === "continue-dir") {
+    const desired = serverConfig(ide);
+    currentPresence = desired ? inspectJsonMcpServerPresence(ide, desired) : "unknown";
+  } else if (ide.mcpConfigFormat === "codex-toml") {
+    currentPresence = inspectCodexPresence(ide);
+  } else if (ide.mcpConfigFormat === "goose-yaml") {
+    currentPresence = inspectGoosePresence(ide);
+  } else {
+    currentPresence = "unknown";
+  }
+  return combineRegistrationPresence(currentPresence, obsoletePresence);
+}
+function combineRegistrationPresence(...values) {
+  if (values.includes("present")) return "present";
+  return values.every((value) => value === "absent") ? "absent" : "unknown";
+}
+function obsoleteJsonRegistrationPaths(ide) {
+  const paths = ide.legacyMcpConfigPaths ?? [];
+  if (!Array.isArray(paths) || paths.length > 8) return void 0;
+  const unique = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    if (typeof path !== "string" || !isAbsolute(path) || path === ide.mcpConfigPath || unique.has(path)) {
+      return void 0;
+    }
+    unique.add(path);
+  }
+  return [...unique];
+}
+function obsoleteJsonIde(ide, path) {
+  return {
+    adapterId: ide.adapterId,
+    name: ide.name,
+    detected: ide.detected,
+    mcpConfigPath: path,
+    mcpConfigFormat: "mcp-json"
+  };
+}
+function inspectObsoleteJsonRegistrationPresence(ide) {
+  const paths = obsoleteJsonRegistrationPaths(ide);
+  if (!paths) return "unknown";
+  return combineRegistrationPresence(...paths.map(
+    (path) => inspectJsonMcpServerPresence(
+      obsoleteJsonIde(ide, path),
+      { command: "agentcache", args: boundServeArgs(ide) }
+    )
+  ));
+}
+function cleanOneObsoleteJsonRegistration(ide) {
+  const paths = obsoleteJsonRegistrationPaths(ide);
+  if (!paths) return "unknown";
+  const candidates = [];
+  for (const path of paths) {
+    const file = parseJsonFile(path);
+    if (!file || !validServerMap(file.config.mcpServers)) return "unknown";
+    if (!file.file.expectation.existed || file.config.mcpServers === void 0) continue;
+    const legacyIde = obsoleteJsonIde(ide, path);
+    const current = registrationOwnership(
+      file.config,
+      legacyIde,
+      { command: "agentcache", args: boundServeArgs(ide) }
+    );
+    const legacy = legacyLoopRegistrationOwnership(file.config);
+    if (current === "ambiguous" || legacy === "ambiguous") return "unknown";
+    candidates.push({ path, file, current, legacy });
+  }
+  const candidate = candidates.find(
+    ({ current, legacy }) => current === "owned" || legacy === "owned"
+  );
+  if (!candidate) return "absent";
+  const servers = candidate.file.config.mcpServers;
+  if (candidate.current === "owned") delete servers.agentcache;
+  if (candidate.legacy === "owned") delete servers.loop;
+  const result = writeJson(
+    candidate.path,
+    candidate.file.config,
+    candidate.file.file.expectation
+  );
+  return !result.conflict && !result.unsupported && result.changed ? "cleaned" : "unknown";
+}
+function inspectClaudeSettingsPresence(path) {
+  const file = readBoundedRegistrationFile(path, true);
+  if (!file) return "unknown";
+  if (!file.expectation.existed) return "absent";
+  let settings;
+  try {
+    settings = JSON.parse(file.content);
+  } catch {
+    return "unknown";
+  }
+  const duplicateKeys = jsonHasDuplicateKeys(file.content);
+  if (duplicateKeys === void 0 || !isJsonObject(settings)) return "unknown";
+  let ambiguous = duplicateKeys;
+  if (settings.mcpServers !== void 0 && !isJsonObject(settings.mcpServers)) {
+    return "unknown";
+  }
+  for (const key of ["loop", "agentcache"]) {
+    const ownership = legacyClaudeSettingsRegistrationOwnership(settings, key);
+    if (ownership === "owned") return "present";
+    if (ownership === "ambiguous") ambiguous = true;
+  }
+  const permissions = settings.permissions;
+  if (permissions !== void 0) {
+    if (!isJsonObject(permissions)) return "unknown";
+    const allow = permissions.allow;
+    if (allow !== void 0) {
+      if (!Array.isArray(allow)) return "unknown";
+      if (allow.some(
+        (permission) => typeof permission === "string" && permission.startsWith("mcp__agentcache__")
+      )) {
+        return "present";
+      }
+    }
+  }
+  const hookOwnership = legacyClaudeHookOwnership(settings);
+  if (hookOwnership === "owned") return "present";
+  if (hookOwnership === "ambiguous") ambiguous = true;
+  return ambiguous ? "unknown" : "absent";
+}
+function registerClaudeCode(ide) {
+  const configFile = parseJsonFile(ide.mcpConfigPath);
+  const settingsPath = claudeSettingsPath(ide);
+  const settingsFile = parseJsonFile(settingsPath);
+  if (!configFile || !settingsFile || !validServerMap(configFile.config.mcpServers)) {
+    return skipped("malformed or unsupported JSON config preserved");
+  }
+  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");
+  }
+  if (legacyClaudeHookOwnership(settings) === "ambiguous") {
+    return skipped("ambiguous Claude legacy hook preserved");
+  }
+  if (legacyLoopRegistrationOwnership(config) === "owned" && isJsonObject(config.mcpServers)) {
+    delete config.mcpServers.loop;
+  }
+  config.mcpServers ??= {};
+  config.mcpServers.agentcache = desired;
+  const permissionsChanged = removeAgentCachePermissions(settings);
+  const hooksChanged = removeAgentCacheHooks(settings);
+  const registrationsChanged = removeLegacyClaudeMcpServers(settings);
+  const settingsChanged = permissionsChanged || hooksChanged || registrationsChanged;
+  if (settingsChanged) {
+    const settingsWrite = writeJson(settingsPath, settings, settingsFile.file.expectation);
+    if (settingsWrite.conflict) return skipped("Claude settings changed during registration");
+    if (settingsWrite.unsupported) {
+      return skipped("safe atomic Claude settings publication unsupported");
+    }
+    return skipped("Claude legacy settings cleaned; run registration again");
+  }
+  const nextConfig = jsonFileContents(config);
+  const configWrite = atomicWriteFileSync(
+    ide.mcpConfigPath,
+    nextConfig,
+    configFile.file.expectation
+  );
+  if (configWrite.conflict) return skipped("Claude config changed during registration");
+  if (configWrite.unsupported) {
+    return skipped("safe atomic Claude config publication unsupported");
+  }
+  const currentSettings = parseJsonFile(settingsPath);
+  if (!currentSettings || hasLegacyClaudeSettings(currentSettings.config)) {
+    if (!configWrite.changed) {
+      return skipped("Claude settings became unsafe; existing registration preserved");
+    }
+    const restored = restorePublishedFile(
+      ide.mcpConfigPath,
+      Buffer.from(nextConfig, "utf8"),
+      configFile.file.expectation
+    );
+    return restored ? skipped("Claude settings became unsafe; registration rolled back") : skipped("Claude settings became unsafe; registration rollback could not be completed");
+  }
+  return registrationResult(configWrite.changed);
+}
+function unregisterClaudeCode(ide) {
+  const configFile = parseJsonFile(ide.mcpConfigPath);
+  const settingsPath = claudeSettingsPath(ide);
+  const settingsFile = parseJsonFile(settingsPath);
+  if (!configFile || !settingsFile || !validServerMap(configFile.config.mcpServers)) return false;
+  const config = configFile.config;
+  const settings = settingsFile.config;
+  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);
+  const permissionsChanged = removeAgentCachePermissions(settings);
+  const hooksChanged = removeAgentCacheHooks(settings);
+  const registrationsChanged = removeLegacyClaudeMcpServers(settings);
+  const settingsChanged = permissionsChanged || hooksChanged || registrationsChanged;
+  if (settingsChanged) {
+    const settingsWrite = writeJson(settingsPath, settings, settingsFile.file.expectation);
+    return !settingsWrite.conflict && !settingsWrite.unsupported && settingsWrite.changed;
+  }
+  let configChanged = false;
+  if (ownership === "owned") {
+    delete config.mcpServers.agentcache;
+    configChanged = true;
+  }
+  if (legacyOwnership === "owned") {
+    delete config.mcpServers.loop;
+    configChanged = true;
+  }
+  if (!configChanged) return false;
+  const result = writeJson(ide.mcpConfigPath, config, configFile.file.expectation);
+  return !result.conflict && !result.unsupported && result.changed;
+}
+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",
+    ...pinned,
+    env: {}
+  };
+}
+function serverConfig(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);
+  if (!config || !validServerMap(config.mcpServers) || !config.mcpServers) return false;
+  const existing = config.mcpServers.agentcache;
+  if (!isJsonObject(existing) || existing.disabled === true) return false;
+  if (isVscodeExtensionIde(ide)) {
+    return existing.disabled === false && serverCoreMatches(existing, desired);
+  }
+  return serverCoreMatches(existing, desired);
+}
+function inspectJsonMcpServerPresence(ide, desired) {
+  const file = readBoundedRegistrationFile(ide.mcpConfigPath, true);
+  if (!file) return "unknown";
+  if (!file.expectation.existed) return "absent";
+  let config;
+  try {
+    config = JSON.parse(file.content);
+  } catch {
+    return "unknown";
+  }
+  const duplicateKeys = jsonHasDuplicateKeys(file.content);
+  if (duplicateKeys === void 0) return "unknown";
+  if (!isJsonObject(config)) return "unknown";
+  if (config.mcpServers === void 0) return duplicateKeys ? "unknown" : "absent";
+  if (!isJsonObject(config.mcpServers)) return "unknown";
+  const current = registrationOwnership(config, ide, desired);
+  const legacy = legacyLoopRegistrationOwnership(config);
+  if (current === "owned" || legacy === "owned") return "present";
+  if (current === "ambiguous" || legacy === "ambiguous" || duplicateKeys) return "unknown";
+  return "absent";
+}
+function registerMcpJson(ide) {
+  const configFile = parseJsonFile(ide.mcpConfigPath);
+  if (!configFile || !validServerMap(configFile.config.mcpServers)) {
+    return skipped("malformed or unsupported JSON config preserved");
+  }
+  const config = configFile.config;
+  const desired = serverConfig(ide);
+  if (!desired) return skipped("trusted AgentCache CLI entrypoint unavailable");
+  if (registrationOwnership(config, ide, desired) === "ambiguous") {
+    return skipped("ambiguous AgentCache registration preserved");
+  }
+  const legacyOwnership = legacyLoopRegistrationOwnership(config);
+  if (legacyOwnership === "owned" && isJsonObject(config.mcpServers)) {
+    delete config.mcpServers.loop;
+  }
+  config.mcpServers ??= {};
+  config.mcpServers.agentcache = desired;
+  return registrationWriteResult(
+    writeJson(ide.mcpConfigPath, config, configFile.file.expectation),
+    "JSON config changed during registration"
+  );
+}
+function registerContinue(ide) {
+  return registerMcpJson(ide);
+}
+function unregisterJson(ide) {
+  const configFile = parseJsonFile(ide.mcpConfigPath);
+  if (!configFile || !configFile.file.expectation.existed || !validServerMap(configFile.config.mcpServers) || !configFile.config.mcpServers) {
+    return false;
+  }
+  const config = configFile.config;
+  const desired = serverConfig(ide);
+  if (!desired) return false;
+  const currentOwnership = registrationOwnership(config, ide, desired);
+  const legacyOwnership = legacyLoopRegistrationOwnership(config);
+  let changed = false;
+  if (currentOwnership === "owned") {
+    delete config.mcpServers.agentcache;
+    changed = true;
+  }
+  if (legacyOwnership === "owned") {
+    delete config.mcpServers.loop;
+    changed = true;
+  }
+  if (!changed) return false;
+  const result = writeJson(ide.mcpConfigPath, config, configFile.file.expectation);
+  return !result.conflict && result.changed;
+}
+var GOOSE_EXTENSION_KEY = "agentcache";
+function resolveGooseConfigTarget(logicalPath) {
+  if (!isAbsolute(logicalPath) || !atomicWritePathIsSafe(logicalPath)) return void 0;
+  let metadata;
+  try {
+    metadata = lstatSync2(logicalPath);
+  } catch (error) {
+    return missingPath2(error) ? { logicalPath, writePath: logicalPath, existed: false } : void 0;
+  }
+  if (!metadata.isSymbolicLink()) {
+    return metadata.isFile() ? { logicalPath, writePath: logicalPath, existed: true } : void 0;
+  }
+  try {
+    const linkValue = readlinkSync(logicalPath);
+    const writePath = resolve2(dirname2(logicalPath), linkValue);
+    const targetMetadata = lstatSync2(writePath);
+    if (targetMetadata.isSymbolicLink() || !targetMetadata.isFile()) return void 0;
+    return { logicalPath, writePath, existed: true, linkValue };
+  } catch {
+    return void 0;
+  }
+}
+function gooseTargetStillBound(target, expectation) {
+  try {
+    if (target.linkValue !== void 0) {
+      const linkMetadata = lstatSync2(target.logicalPath);
+      if (!linkMetadata.isSymbolicLink()) return false;
+      if (readlinkSync(target.logicalPath) !== target.linkValue) return false;
+    } else if (expectation.existed) {
+      const metadata = lstatSync2(target.logicalPath);
+      if (metadata.isSymbolicLink() || !metadata.isFile()) return false;
+    } else {
+      try {
+        lstatSync2(target.logicalPath);
+        return false;
+      } catch (error) {
+        return missingPath2(error);
+      }
+    }
+    return atomicWriteExpectationMatches(target.writePath, expectation);
+  } catch {
+    return false;
+  }
+}
+function currentPublishedGooseFile(target, contents) {
+  const published = readBoundedRegistrationFile(target.writePath);
+  return published?.expectation.existed && published.expectation.contents.equals(contents) ? published : void 0;
+}
+function restoreGooseTarget(target, published, original) {
+  if (!published?.expectation.existed) return false;
+  const restore = original.existed ? atomicWriteFileSync(target.writePath, original.contents, published.expectation) : atomicRemoveFileSync(target.writePath, published.expectation);
+  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: pinned.command,
+    args: pinned.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, desired) {
+  if (value === void 0) return "absent";
+  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) {
+  const document = parseDocument(content, {
+    prettyErrors: false,
+    strict: true,
+    uniqueKeys: true
+  });
+  if (document.errors.length > 0 || document.warnings.length > 0) return void 0;
+  if (document.contents !== null && !isMap(document.contents)) return void 0;
+  return document;
+}
+function gooseExtensions(document) {
+  if (document.contents === null) return void 0;
+  const extensions = document.get("extensions", true);
+  if (extensions === void 0) return void 0;
+  return isMap(extensions) ? extensions : null;
+}
+function createGooseMap(document, value = {}) {
+  const node = document.createNode(value);
+  return isMap(node) ? node : void 0;
+}
+function registerGoose(ide) {
+  if (!isAbsolute(ide.mcpConfigPath)) {
+    return skipped("unsafe Goose config path preserved");
+  }
+  const target = resolveGooseConfigTarget(ide.mcpConfigPath);
+  if (!target) return skipped("unsupported Goose config symlink preserved");
+  const file = readBoundedRegistrationFile(target.writePath, true);
+  if (!file || file.expectation.existed !== target.existed || !gooseTargetStillBound(target, file.expectation)) {
+    return skipped("malformed or unsupported Goose YAML config preserved");
+  }
+  const original = file.content;
+  const document = parseGooseDocument(original);
+  if (!document) {
+    return skipped("malformed or unsupported Goose YAML config preserved");
+  }
+  let extensions = gooseExtensions(document);
+  if (extensions === null) {
+    return skipped("malformed or unsupported Goose YAML config preserved");
+  }
+  const existingNode = extensions?.get(GOOSE_EXTENSION_KEY, true);
+  let existing;
+  try {
+    existing = existingNode?.toJSON();
+  } catch {
+    return skipped("malformed or unsupported Goose YAML config preserved");
+  }
+  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");
+  }
+  if (ownership === "owned" && Object.entries(desired).every(([key, value]) => {
+    const existingValue = existing[key];
+    return Array.isArray(value) ? argsEqual(existingValue, value) : existingValue === value;
+  })) {
+    return gooseTargetStillBound(target, file.expectation) ? { status: "unchanged" } : skipped("Goose config changed during registration");
+  }
+  if (!extensions) {
+    if (document.contents === null) {
+      const root = createGooseMap(document);
+      if (!root) return skipped("malformed or unsupported Goose YAML config preserved");
+      document.contents = root;
+    }
+    const extensionsNode = createGooseMap(document);
+    if (!extensionsNode || !isMap(document.contents)) {
+      return skipped("malformed or unsupported Goose YAML config preserved");
+    }
+    document.contents.set("extensions", extensionsNode);
+    extensions = extensionsNode;
+  }
+  if (!extensions || !isMap(extensions)) {
+    return skipped("malformed or unsupported Goose YAML config preserved");
+  }
+  if (existingNode && isMap(existingNode)) {
+    for (const [key, value] of Object.entries(desired)) {
+      const existingValue = existing[key];
+      const matches = Array.isArray(value) ? argsEqual(existingValue, value) : existingValue === 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);
+    if (!desiredNode) {
+      return skipped("malformed or unsupported Goose YAML config preserved");
+    }
+    extensions.set(GOOSE_EXTENSION_KEY, desiredNode);
+  }
+  if (!gooseTargetStillBound(target, file.expectation)) {
+    return skipped("Goose config changed during registration");
+  }
+  const next = String(document);
+  const nextBytes = Buffer.from(next, "utf8");
+  const write = atomicWriteFileSync(target.writePath, next, file.expectation);
+  const result = registrationWriteResult(
+    write,
+    "Goose config changed during registration",
+    "safe atomic Goose config publication unsupported"
+  );
+  if (!write.changed) return result;
+  const published = currentPublishedGooseFile(target, nextBytes);
+  if (published && gooseTargetStillBound(target, published.expectation)) return result;
+  const restored = restoreGooseTarget(target, published, file.expectation);
+  return restored ? skipped("Goose config target changed during registration; original target restored") : skipped("Goose config changed after registration; rollback could not be completed");
+}
+function unregisterGoose(ide) {
+  const target = resolveGooseConfigTarget(ide.mcpConfigPath);
+  if (!target?.existed) return false;
+  const file = readBoundedRegistrationFile(target.writePath);
+  if (!file || !gooseTargetStillBound(target, file.expectation)) return false;
+  const original = file.content;
+  const document = parseGooseDocument(original);
+  if (!document) return false;
+  const extensions = gooseExtensions(document);
+  if (!extensions || !isMap(extensions)) return false;
+  const existingNode = extensions.get(GOOSE_EXTENSION_KEY, true);
+  if (!existingNode || !isMap(existingNode)) return false;
+  let existing;
+  try {
+    existing = existingNode.toJSON();
+  } catch {
+    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);
+  const nextBytes = Buffer.from(next, "utf8");
+  const result = atomicWriteFileSync(target.writePath, next, file.expectation);
+  if (result.conflict || result.unsupported || !result.changed) return false;
+  const published = currentPublishedGooseFile(target, nextBytes);
+  if (published && gooseTargetStillBound(target, published.expectation)) return true;
+  restoreGooseTarget(target, published, file.expectation);
+  return false;
+}
+function isGooseRegistered(ide) {
+  const target = resolveGooseConfigTarget(ide.mcpConfigPath);
+  if (!target?.existed) return false;
+  try {
+    const file = readBoundedRegistrationFile(target.writePath);
+    if (!file || !gooseTargetStillBound(target, file.expectation)) return false;
+    const document = parseGooseDocument(file.content);
+    if (!document) return false;
+    const extensions = gooseExtensions(document);
+    if (!extensions || !isMap(extensions)) return false;
+    const entry = extensions.get(GOOSE_EXTENSION_KEY, true);
+    if (!entry || !isMap(entry)) return false;
+    const value = entry.toJSON();
+    const desired = gooseServerConfig(ide);
+    return !!desired && isJsonObject(value) && value.enabled === true && gooseCoreMatches(value, desired);
+  } catch {
+    return false;
+  }
+}
+function inspectGoosePresence(ide) {
+  const target = resolveGooseConfigTarget(ide.mcpConfigPath);
+  if (!target) return "unknown";
+  if (!target.existed) return "absent";
+  try {
+    const file = readBoundedRegistrationFile(target.writePath);
+    if (!file || !gooseTargetStillBound(target, file.expectation)) return "unknown";
+    const document = parseGooseDocument(file.content);
+    if (!document) return "unknown";
+    const extensions = gooseExtensions(document);
+    if (extensions === void 0) return "absent";
+    if (!isMap(extensions)) return "unknown";
+    const entry = extensions.get(GOOSE_EXTENSION_KEY, true);
+    if (entry === void 0) return "absent";
+    if (!isMap(entry)) return "unknown";
+    return gooseOwnership(entry.toJSON(), ide, gooseServerConfig(ide)) === "owned" ? "present" : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function formatCodexBlock(command, args) {
+  return [
+    CODEX_MARKER_START,
+    "[mcp_servers.agentcache]",
+    `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 = "";
+  for (let index = 0; index < content.length; index += 1) {
+    const char = content[index];
+    const triple = content.slice(index, index + 3);
+    if (state === "comment") {
+      masked += char;
+      if (char === "\n") state = "normal";
+      continue;
+    }
+    if (state === "basic") {
+      if (char === "\n" || char === "\r") return void 0;
+      masked += " ";
+      if (char === "\\") {
+        if (index + 1 >= content.length || content[index + 1] === "\n") return void 0;
+        masked += " ";
+        index += 1;
+      } else if (char === '"') {
+        state = "normal";
+      }
+      continue;
+    }
+    if (state === "literal") {
+      if (char === "\n" || char === "\r") return void 0;
+      masked += " ";
+      if (char === "'") state = "normal";
+      continue;
+    }
+    if (state === "multi-basic") {
+      if (triple === '"""') {
+        masked += "   ";
+        index += 2;
+        state = "normal";
+      } else {
+        masked += char === "\n" ? "\n" : " ";
+        if (char === "\\" && index + 1 < content.length) {
+          masked += content[index + 1] === "\n" ? "\n" : " ";
+          index += 1;
+        }
+      }
+      continue;
+    }
+    if (state === "multi-literal") {
+      if (triple === "'''") {
+        masked += "   ";
+        index += 2;
+        state = "normal";
+      } else {
+        masked += char === "\n" ? "\n" : " ";
+      }
+      continue;
+    }
+    if (triple === '"""') {
+      masked += "   ";
+      index += 2;
+      state = "multi-basic";
+    } else if (triple === "'''") {
+      masked += "   ";
+      index += 2;
+      state = "multi-literal";
+    } else if (char === '"') {
+      masked += " ";
+      state = "basic";
+    } else if (char === "'") {
+      masked += " ";
+      state = "literal";
+    } else if (char === "#") {
+      masked += char;
+      state = "comment";
+    } else {
+      masked += char;
+    }
+  }
+  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;
+  const lines = [];
+  const headers = [];
+  const markerStarts = [];
+  const markerEnds = [];
+  let squareDepth = 0;
+  let inlineTableDepth = 0;
+  let offset = 0;
+  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;
+    const commentAt = maskedLine.indexOf("#");
+    const code = (commentAt < 0 ? maskedLine : maskedLine.slice(0, commentAt)).trim();
+    const line = { start: offset, end, code, marker };
+    lines.push(line);
+    if (marker === "start") markerStarts.push(line);
+    if (marker === "end") markerEnds.push(line);
+    if (code.startsWith("[") && squareDepth === 0 && inlineTableDepth === 0) {
+      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;
+      for (const char of code) {
+        if (char === "[") squareDepth += 1;
+        else if (char === "]") squareDepth -= 1;
+        else if (char === "{") inlineTableDepth += 1;
+        else if (char === "}") inlineTableDepth -= 1;
+        if (squareDepth < 0 || inlineTableDepth < 0) return void 0;
+      }
+    }
+    offset = end;
+  }
+  if (squareDepth !== 0 || inlineTableDepth !== 0) return void 0;
+  if (markerStarts.length > 1 || markerEnds.length > 1) return void 0;
+  if (markerStarts.length === 1 !== (markerEnds.length === 1)) return void 0;
+  if (markerStarts[0] && markerEnds[0] && markerStarts[0].start >= markerEnds[0].start) {
+    return void 0;
+  }
+  for (let index = 0; index < headers.length; index += 1) {
+    headers[index].end = headers[index + 1]?.start ?? content.length;
+  }
+  return {
+    lines,
+    headers,
+    markerStart: markerStarts[0],
+    markerEnd: markerEnds[0]
+  };
+}
+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 === 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 || 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, allowManagedNodeWrapper = false) {
+  const ownedHeaders = scan.headers.filter(isOwnedCodexHeader);
+  if (ownedHeaders.length === 0) return void 0;
+  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 hasLegacyApproval = false;
+  let semanticServer;
+  try {
+    const parsed = parseToml(content);
+    const table = parsed.mcp_servers?.agentcache;
+    if (!isJsonObject(table)) return null;
+    semanticServer = { command: table.command, args: table.args };
+  } catch {
+    return null;
+  }
+  for (const line of bodyLines) {
+    const source = content.slice(line.start, line.end).trim();
+    if (/^command\s*=/.test(source)) {
+      if (hasCommand) return null;
+      hasCommand = true;
+    } else if (/^args\s*=/.test(source)) {
+      if (hasArgs) return null;
+      hasArgs = true;
+    } else if (/^default_tools_approval_mode\s*=\s*"auto"\s*(?:#.*)?$/.test(source)) {
+      hasLegacyApproval = true;
+    } else return null;
+  }
+  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: current && !hasLegacyApproval
+  } : null;
+}
+function removeCodexRange(content, range) {
+  let start = range.start;
+  if (range.end === content.length && content.slice(0, start).endsWith("\n\n")) start -= 2;
+  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;
+  if (!isValidToml(original)) {
+    return skipped("malformed or ambiguous TOML config preserved");
+  }
+  const scan = scanToml(original);
+  if (!scan) return skipped("malformed or ambiguous TOML config preserved");
+  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) + 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");
+  }
+  return registrationWriteResult(
+    atomicWriteFileSync(ide.mcpConfigPath, next, file.expectation),
+    "Codex config changed during registration"
+  );
+}
+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, desiredBlock);
+  if (managed === null) return false;
+  const legacy = managed ? void 0 : legacyCodexRange(original, scan, ide);
+  if (legacy === null) return false;
+  const range = managed ?? legacy;
+  if (!range) return false;
+  const next = removeCodexRange(original, range);
+  if (!isValidToml(next)) return false;
+  const result = atomicWriteFileSync(ide.mcpConfigPath, next, file.expectation);
+  return !result.conflict && result.changed;
+}
+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, desiredBlock);
+    if (managed === null) return false;
+    if (managed) return managed.current;
+    const recognized = legacyCodexRange(original, scan, ide);
+    return recognized?.current === true;
+  } catch {
+    return false;
+  }
+}
+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";
+    const original = file.content;
+    if (!isValidToml(original)) return "unknown";
+    const scan = scanToml(original);
+    if (!scan) return "unknown";
+    const managed = managedCodexRange(original, scan, ide, desiredBlock);
+    if (managed === null) return "unknown";
+    if (managed) return "present";
+    const legacy = legacyCodexRange(original, scan, ide);
+    if (legacy === null) return "unknown";
+    return legacy ? "present" : "absent";
+  } catch {
+    return "unknown";
+  }
+}
+function registerClaudeHooks(settingsPath = claudeSettingsPath()) {
+  const settingsFile = parseJsonFile(settingsPath);
+  if (!settingsFile || !settingsFile.file.expectation.existed || legacyClaudeHookOwnership(settingsFile.config) === "ambiguous" || !removeAgentCacheHooks(settingsFile.config)) {
+    return false;
+  }
+  const result = writeJson(settingsPath, settingsFile.config, settingsFile.file.expectation);
+  return !result.conflict && result.changed;
+}
+
+export {
+  configureMcpRegistrationEntrypoint,
+  inspectLegacyClaudeHookPresence,
+  registerMcpServer,
+  unregisterMcpServer,
+  isMcpServerRegistered,
+  inspectMcpServerPresence,
+  registerClaudeHooks
+};