@cortexkit/magic-context 0.43.0 → 0.43.2

package/dist/index.js

@@ -3940,6 +3940,13 @@ function getHarness() {
 }
 var currentHarness = "opencode";
 
+// ../plugin/src/shared/test-temp-dir.ts
+var STALE_TEMP_DIR_AGE_MS, registeredTempDirs;
+var init_test_temp_dir = __esm(() => {
+  STALE_TEMP_DIR_AGE_MS = 60 * 60 * 1000;
+  registeredTempDirs = new Set;
+});
+
 // ../plugin/src/shared/data-path.ts
 var exports_data_path = {};
 __export(exports_data_path, {
@@ -4018,7 +4025,9 @@ function getMagicContextStorageDir() {
 function getLegacyOpenCodeMagicContextStorageDir() {
   return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
 }
-var init_data_path = () => {};
+var init_data_path = __esm(() => {
+  init_test_temp_dir();
+});
 
 // src/lib/paths.ts
 import { existsSync as existsSync4, readdirSync, statSync as statSync3 } from "node:fs";
@@ -4194,6 +4203,10 @@ function getOpenCodePluginCacheDir() {
   const xdg = process.env.XDG_CACHE_HOME || join5(homedir3(), ".cache");
   return join5(xdg, "opencode", "packages");
 }
+function getOpenCodeV2NpmCacheDir() {
+  const xdg = process.env.XDG_CACHE_HOME || join5(homedir3(), ".cache");
+  return join5(xdg, "opencode", "npm");
+}
 function isDir(path) {
   try {
     return statSync3(path).isDirectory();
@@ -4594,7 +4607,7 @@ class OmpAdapter {
   }
   getPluginCacheInfo() {
     const path = join8(getOmpPluginsDir(), "cache");
-    return { path, exists: existsSync6(path), sizeBytes: dirSizeBytes(path) };
+    return [{ path, exists: existsSync6(path), sizeBytes: dirSizeBytes(path) }];
   }
   getLogPath() {
     return getMagicContextLogPath2("omp");
@@ -4637,7 +4650,7 @@ var init_omp = __esm(() => {
 // ../plugin/src/shared/opencode-db-path.ts
 import { existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync4 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { isAbsolute as isAbsolute3, join as join9 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join9, resolve as resolve3 } from "node:path";
 function openCodeHostGenerationFromVersion(version) {
   const text = version ?? "";
   if (/(?:^|\s|v)0\.0\.0-(?:beta|dev)-/.test(text))
@@ -4724,7 +4737,7 @@ function resolveV2Fresh(dataDir, channel, env) {
   const filename = sourceOpenCodeDatabaseFilename("v2", channel, env);
   const explicit = env.OPENCODE_DB !== undefined;
   return {
-    path: filename === ":memory:" ? filename : join9(dataDir, filename),
+    path: filename === ":memory:" ? filename : resolve3(dataDir, filename),
     source: explicit ? "OPENCODE_DB" : env.OPENCODE_CHANNEL ? "channel" : "default",
     channel: explicit ? null : channel
   };
@@ -12643,6 +12656,323 @@ var require_src3 = __commonJS(function(exports, module) {
   };
 });
 
+// ../plugin/src/hooks/auto-update-checker/semver.ts
+function isValidSemver(version) {
+  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version);
+}
+function compareSemverCore(a, b) {
+  if (!isValidSemver(a) || !isValidSemver(b))
+    return null;
+  const core = (v) => v.split(/[-+]/, 1)[0].split(".").map((n) => Number.parseInt(n, 10));
+  const [a0, a1, a2] = core(a);
+  const [b0, b1, b2] = core(b);
+  return a0 - b0 || a1 - b1 || a2 - b2;
+}
+
+// src/lib/opencode-plugin-registration.ts
+function pluginConfigKeyFor(hostGeneration) {
+  return hostGeneration === "v2" ? "plugins" : "plugin";
+}
+function readPluginEntries(config) {
+  const out = [];
+  for (const key of OPENCODE_PLUGIN_CONFIG_KEYS) {
+    const list = config?.[key];
+    if (!Array.isArray(list))
+      continue;
+    for (const [index, entry] of list.entries())
+      out.push({ key, index, entry });
+  }
+  return out;
+}
+var OPENCODE_PLUGIN_CONFIG_KEYS;
+var init_opencode_plugin_registration = __esm(() => {
+  OPENCODE_PLUGIN_CONFIG_KEYS = ["plugin", "plugins"];
+});
+
+// src/lib/opencode-plugin-cache.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync5 } from "node:fs";
+import { join as join10 } from "node:path";
+function getOpenCodePluginCacheRoots() {
+  const cacheDir = getOpenCodePluginCacheDir();
+  return [
+    join10(cacheDir, OPENCODE_PLUGIN_ENTRY_WITH_VERSION),
+    join10(cacheDir, OPENCODE_PLUGIN_NAME)
+  ];
+}
+function getOpenCodePluginPackageJsonPath(pluginCacheRoot) {
+  return join10(pluginCacheRoot, "node_modules", ...OPENCODE_PLUGIN_NAME.split("/"), "package.json");
+}
+function getOpenCodePluginPackageJsonPaths() {
+  return getOpenCodePluginCacheRoots().map(getOpenCodePluginPackageJsonPath);
+}
+function getOpenCodeV2PluginCacheSlot(npmCacheDir = getOpenCodeV2NpmCacheDir(), spec = "latest") {
+  return join10(npmCacheDir, ...`${OPENCODE_PLUGIN_NAME}@${spec}`.split("/"));
+}
+function openCodeV2PluginSpecOf(specifier) {
+  if (specifier === OPENCODE_PLUGIN_NAME)
+    return "latest";
+  const prefix = `${OPENCODE_PLUGIN_NAME}@`;
+  if (!specifier.startsWith(prefix))
+    return;
+  const spec = specifier.slice(prefix.length);
+  return spec.length > 0 ? spec : "latest";
+}
+function isOpenCodePluginDistTag(spec) {
+  return /^[A-Za-z][A-Za-z0-9._-]*$/.test(spec) && !/^(v\d|[xX]$)/.test(spec);
+}
+function readConfiguredOpenCodePluginSpec(config) {
+  for (const { entry } of readPluginEntries(config)) {
+    const specifier = pluginEntrySpecifier(entry);
+    const spec = specifier === undefined ? undefined : openCodeV2PluginSpecOf(specifier);
+    if (spec !== undefined)
+      return spec;
+  }
+  return "latest";
+}
+function pluginEntrySpecifier(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (Array.isArray(entry) && typeof entry[0] === "string")
+    return entry[0];
+  if (entry !== null && typeof entry === "object") {
+    const pkg = entry.package;
+    if (typeof pkg === "string")
+      return pkg;
+  }
+  return;
+}
+function listOpenCodeV2PluginCacheSlots(npmCacheDir = getOpenCodeV2NpmCacheDir()) {
+  const [scope = "", name = ""] = OPENCODE_PLUGIN_NAME.split("/");
+  const scopeDir = join10(npmCacheDir, scope);
+  let names;
+  try {
+    names = readdirSync3(scopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith(`${name}@`)).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+  return names.map((dirName) => {
+    const slot = join10(scopeDir, dirName);
+    return {
+      spec: dirName.slice(name.length + 1),
+      slot,
+      version: readOpenCodeV2CachedPluginVersion(slot)
+    };
+  }).sort((a, b) => {
+    if (a.spec === "latest" || b.spec === "latest")
+      return a.spec === "latest" ? -1 : 1;
+    return a.spec.localeCompare(b.spec);
+  });
+}
+function getOpenCodeV2ActiveGeneration(slot) {
+  try {
+    const generations = readdirSync3(slot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^\d+$/.test(entry.name)).map((entry) => entry.name).sort((a, b) => Number(a) - Number(b));
+    const newest = generations.at(-1);
+    return newest === undefined ? undefined : join10(slot, newest);
+  } catch {
+    return;
+  }
+}
+function readOpenCodeV2CachedPluginVersion(slot) {
+  const generation = getOpenCodeV2ActiveGeneration(slot);
+  if (!generation)
+    return;
+  try {
+    const pkg = JSON.parse(readFileSync5(getOpenCodePluginPackageJsonPath(generation), "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : undefined;
+  } catch {
+    return;
+  }
+}
+var OPENCODE_PLUGIN_NAME = "@cortexkit/opencode-magic-context", OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
+var init_opencode_plugin_cache = __esm(() => {
+  init_opencode_plugin_registration();
+  init_paths();
+  OPENCODE_PLUGIN_ENTRY_WITH_VERSION = `${OPENCODE_PLUGIN_NAME}@latest`;
+});
+
+// src/commands/doctor-opencode2-cache.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync8, rmSync as rmSync2 } from "node:fs";
+function runLsof(args, spawn) {
+  const result = spawn("lsof", args, { encoding: "utf-8", timeout: 15000 });
+  if (result.error)
+    return { error: result.error.message };
+  if (result.status !== 0 && result.status !== 1) {
+    return { error: `lsof exited with status ${String(result.status)}` };
+  }
+  const pids = (result.stdout ?? "").split(/\s+/).filter((token) => /^\d+$/.test(token)).map((token) => Number(token)).filter((pid) => pid !== process.pid);
+  return { pids };
+}
+function probeHostProcessesUsing(targets, spawn = spawnSync3) {
+  const files = targets.files.filter((file) => existsSync8(file));
+  const directories = targets.directories.filter((directory) => existsSync8(directory));
+  const queries = [];
+  if (files.length > 0)
+    queries.push(["-w", "-t", "--", ...files]);
+  for (const directory of directories)
+    queries.push(["-w", "-t", "+D", directory]);
+  const pids = new Set;
+  for (const args of queries) {
+    const result = runLsof(args, spawn);
+    if ("error" in result) {
+      return { status: "unknown", reason: `could not run lsof (${result.error})` };
+    }
+    for (const pid of result.pids)
+      pids.add(pid);
+  }
+  if (pids.size > 0)
+    return { status: "in_use", pids: [...pids].sort((a, b) => a - b) };
+  return { status: "free" };
+}
+function comparePrerelease(a, b) {
+  if (a === b)
+    return 0;
+  if (a === "")
+    return 1;
+  if (b === "")
+    return -1;
+  const left = a.split(".");
+  const right = b.split(".");
+  for (let i = 0;i < Math.max(left.length, right.length); i++) {
+    const x = left[i];
+    const y = right[i];
+    if (x === undefined)
+      return -1;
+    if (y === undefined)
+      return 1;
+    if (x === y)
+      continue;
+    const xNumeric = /^\d+$/.test(x);
+    const yNumeric = /^\d+$/.test(y);
+    if (xNumeric && yNumeric)
+      return Number(x) - Number(y);
+    if (xNumeric !== yNumeric)
+      return xNumeric ? -1 : 1;
+    return x < y ? -1 : 1;
+  }
+  return 0;
+}
+function prereleaseOf(version) {
+  const withoutBuild = version.split("+", 1)[0] ?? "";
+  const dash = withoutBuild.indexOf("-");
+  return dash === -1 ? "" : withoutBuild.slice(dash + 1);
+}
+function isStale(cached, latest) {
+  if (cached === undefined)
+    return true;
+  if (cached === latest)
+    return false;
+  const comparison = compareSemverCore(cached, latest);
+  if (comparison === null)
+    return true;
+  if (comparison !== 0)
+    return comparison < 0;
+  return comparePrerelease(prereleaseOf(cached), prereleaseOf(latest)) < 0;
+}
+function removeOpenCodeV2PluginCacheSlot(slot, hostFiles, deps = {}) {
+  const probe = deps.probe ?? probeHostProcessesUsing;
+  const use = probe({ files: hostFiles, directories: [slot] });
+  if (use.status === "in_use")
+    return { action: "in_use", pids: use.pids };
+  if (use.status === "unknown")
+    return { action: "in_use_unknown", reason: use.reason };
+  const remove = deps.remove ?? ((path) => rmSync2(path, { recursive: true, force: true }));
+  try {
+    remove(slot);
+  } catch (err) {
+    return { action: "error", error: err instanceof Error ? err.message : String(err) };
+  }
+  return { action: "cleared" };
+}
+function openCodeHostDatabaseFiles(databasePaths) {
+  return databasePaths.filter((path) => path !== ":memory:").flatMap((path) => ["", "-wal", "-shm"].map((suffix) => `${path}${suffix}`));
+}
+function configuredOpenCodeV2DistTag(config) {
+  const spec = readConfiguredOpenCodePluginSpec(config);
+  return spec !== "latest" && isOpenCodePluginDistTag(spec) ? spec : undefined;
+}
+function checkOpenCodeV2PluginCache(options, deps = {}) {
+  const distTag = options.distTag && options.distTag !== "latest" ? options.distTag : undefined;
+  const slot = deps.slot ?? getOpenCodeV2PluginCacheSlot(undefined, distTag ?? "latest");
+  const tagged = distTag ? { distTag } : {};
+  if (!existsSync8(slot))
+    return { action: "not_found", slot, ...tagged };
+  const cached = readOpenCodeV2CachedPluginVersion(slot);
+  const latest = options.latestVersion ?? undefined;
+  const force = options.force === true;
+  if (latest === undefined && !force) {
+    return { action: "check_unavailable", slot, cached, ...tagged };
+  }
+  const stale = latest !== undefined && isStale(cached, latest);
+  if (!stale && !force)
+    return { action: "up_to_date", slot, cached, latest, ...tagged };
+  if (!force && options.fix !== true) {
+    return { action: "stale", slot, cached, latest, ...tagged };
+  }
+  const removal = removeOpenCodeV2PluginCacheSlot(slot, options.hostFiles, deps);
+  switch (removal.action) {
+    case "in_use":
+      return { action: "in_use", slot, cached, latest, pids: removal.pids, ...tagged };
+    case "in_use_unknown":
+      return {
+        action: "in_use_unknown",
+        slot,
+        cached,
+        latest,
+        reason: removal.reason,
+        ...tagged
+      };
+    case "error":
+      return { action: "error", slot, cached, latest, error: removal.error, ...tagged };
+    case "cleared":
+      return { action: "cleared", slot, cached, latest, forced: !stale, ...tagged };
+  }
+}
+function reportOpenCodeV2PluginCache(result, report, options) {
+  const tag = result.distTag ?? "latest";
+  const versions = `cached: ${result.cached ?? "unreadable"}${result.latest ? `, ${tag}: ${result.latest}` : ""}`;
+  const slotName = result.distTag ? ` @${result.distTag}` : "";
+  switch (result.action) {
+    case "not_found":
+      if (options.reportMissing) {
+        report.pass(`OpenCode 2 plugin cache has no Magic Context${slotName} install yet (OpenCode installs it on next start)`);
+      }
+      return { fixed: false, issue: false };
+    case "up_to_date":
+      report.pass(`OpenCode 2 plugin cache${slotName} up to date (v${result.cached})`);
+      return { fixed: false, issue: false };
+    case "check_unavailable":
+      report.warn(`OpenCode 2 plugin cache${slotName} version check unavailable; preserving cached plugin${result.cached ? ` (cached: ${result.cached})` : ""}. Use doctor --force to reinstall it.`);
+      return { fixed: false, issue: false };
+    case "stale":
+      report.warn(`OpenCode 2 is running an outdated Magic Context${slotName} (${versions}); OpenCode does not install new releases on its own`);
+      report.info(`  To upgrade, ${OPENCODE_V2_PLUGIN_UPDATE_HINT},`);
+      report.info("  or quit OpenCode (including `opencode service stop`) and run `magic-context doctor --fix`.");
+      return { fixed: false, issue: false };
+    case "in_use":
+      report.warn(`Outdated Magic Context in the OpenCode 2 plugin cache (${versions}) was not cleared: OpenCode is running (pid ${result.pids?.join(", ")})`);
+      report.info(`  Quit OpenCode (and \`opencode service stop\`) and rerun doctor --fix, or ${OPENCODE_V2_PLUGIN_UPDATE_HINT}.`);
+      report.info(`  ${result.slot}`);
+      return { fixed: false, issue: false };
+    case "in_use_unknown":
+      report.warn(`Outdated Magic Context in the OpenCode 2 plugin cache (${versions}) was not cleared: ${result.reason ?? "could not tell whether OpenCode is running"}`);
+      report.info(`  Quit OpenCode and delete ${result.slot} by hand, or ${OPENCODE_V2_PLUGIN_UPDATE_HINT}.`);
+      return { fixed: false, issue: false };
+    case "cleared":
+      report.pass(`Cleared ${result.forced ? "" : "outdated "}Magic Context${slotName} from the OpenCode 2 plugin cache (${versions}${result.forced ? ", --force" : ""}) — OpenCode installs the ${result.distTag ? `current ${tag} release` : "latest"} on next start`);
+      report.info(`  ${result.slot}`);
+      return { fixed: true, issue: false };
+    case "error":
+      report.warn(`Could not clear the OpenCode 2 plugin cache: ${result.error}`);
+      report.info(`  Manually delete: ${result.slot}`);
+      return { fixed: false, issue: true };
+  }
+}
+var OPENCODE_V2_PLUGIN_UPDATE_HINT = "update it from OpenCode: open /plugins, select Magic Context and press ctrl+u (ctrl+r only re-checks), or run `opencode plugin update`";
+var init_doctor_opencode2_cache = __esm(() => {
+  init_opencode_plugin_cache();
+});
+
 // src/lib/atomic-write.ts
 import { chmodSync, mkdirSync as mkdirSync2, renameSync as renameSync2, statSync as statSync5, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
@@ -12661,13 +12991,13 @@ function writeFileAtomic(targetPath, data) {
 var init_atomic_write = () => {};
 
 // src/lib/opencode-detect.ts
-import { existsSync as existsSync8, realpathSync } from "node:fs";
+import { existsSync as existsSync9, realpathSync } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function defaultDeps(overrides = {}) {
   const env = overrides.env ?? process.env;
   return {
-    exists: overrides.exists ?? existsSync8,
+    exists: overrides.exists ?? existsSync9,
     isExecutable: overrides.isExecutable ?? isExecutableFile,
     home: overrides.home ?? (env.HOME?.trim() || homedir7()),
     platform: overrides.platform ?? process.platform,
@@ -12677,7 +13007,7 @@ function defaultDeps(overrides = {}) {
   };
 }
 function stockCliBinary(d) {
-  return d.platform === "win32" ? join10(d.home, ".opencode", "bin", "opencode.exe") : join10(d.home, ".opencode", "bin", "opencode");
+  return d.platform === "win32" ? join11(d.home, ".opencode", "bin", "opencode.exe") : join11(d.home, ".opencode", "bin", "opencode");
 }
 function extraCliCandidates(d) {
   if (d.platform === "win32") {
@@ -12686,25 +13016,25 @@ function extraCliCandidates(d) {
     const userprofile = d.env.USERPROFILE ?? d.home;
     const out = [];
     if (appdata) {
-      out.push(join10(appdata, "npm", "opencode.cmd"));
-      out.push(join10(appdata, "npm", "opencode.exe"));
+      out.push(join11(appdata, "npm", "opencode.cmd"));
+      out.push(join11(appdata, "npm", "opencode.exe"));
     }
     if (localappdata) {
-      out.push(join10(localappdata, "Microsoft", "WinGet", "Links", "opencode.exe"));
-      out.push(join10(localappdata, "opencode", "bin", "opencode.exe"));
+      out.push(join11(localappdata, "Microsoft", "WinGet", "Links", "opencode.exe"));
+      out.push(join11(localappdata, "opencode", "bin", "opencode.exe"));
     }
     if (userprofile) {
-      out.push(join10(userprofile, "scoop", "shims", "opencode.exe"));
+      out.push(join11(userprofile, "scoop", "shims", "opencode.exe"));
     }
     return out;
   }
   return [
     "/usr/local/bin/opencode",
     "/opt/homebrew/bin/opencode",
-    join10(d.home, ".local", "bin", "opencode"),
-    join10(d.home, ".local", "share", "mise", "shims", "opencode"),
-    join10(d.home, ".asdf", "shims", "opencode"),
-    join10(d.home, ".volta", "bin", "opencode")
+    join11(d.home, ".local", "bin", "opencode"),
+    join11(d.home, ".local", "share", "mise", "shims", "opencode"),
+    join11(d.home, ".asdf", "shims", "opencode"),
+    join11(d.home, ".volta", "bin", "opencode")
   ];
 }
 function canonicalPath(d, path) {
@@ -12725,29 +13055,29 @@ function xdgConfigHome(d) {
   const xdg = d.env.XDG_CONFIG_HOME;
   if (xdg && xdg.length > 0)
     return xdg;
-  return join10(d.home, ".config");
+  return join11(d.home, ".config");
 }
 function desktopUserDataDir(d, appId) {
   switch (d.platform) {
     case "darwin":
-      return join10(d.home, "Library", "Application Support", appId);
+      return join11(d.home, "Library", "Application Support", appId);
     case "win32":
-      return join10(d.env.APPDATA ?? join10(d.home, "AppData", "Roaming"), appId);
+      return join11(d.env.APPDATA ?? join11(d.home, "AppData", "Roaming"), appId);
     default:
-      return join10(xdgConfigHome(d), appId);
+      return join11(xdgConfigHome(d), appId);
   }
 }
 function desktopAppPaths(d) {
   switch (d.platform) {
     case "darwin":
-      return ["/Applications/OpenCode.app", join10(d.home, "Applications", "OpenCode.app")];
+      return ["/Applications/OpenCode.app", join11(d.home, "Applications", "OpenCode.app")];
     case "win32": {
-      const localappdata = d.env.LOCALAPPDATA ?? join10(d.home, "AppData", "Local");
-      return [join10(localappdata, "Programs", "OpenCode", "OpenCode.exe")];
+      const localappdata = d.env.LOCALAPPDATA ?? join11(d.home, "AppData", "Local");
+      return [join11(localappdata, "Programs", "OpenCode", "OpenCode.exe")];
     }
     default: {
-      const dataHome = d.env.XDG_DATA_HOME && d.env.XDG_DATA_HOME.length > 0 ? d.env.XDG_DATA_HOME : join10(d.home, ".local", "share");
-      return OPENCODE_DESKTOP_APP_IDS.map((appId) => join10(dataHome, "applications", `${appId}.desktop`));
+      const dataHome = d.env.XDG_DATA_HOME && d.env.XDG_DATA_HOME.length > 0 ? d.env.XDG_DATA_HOME : join11(d.home, ".local", "share");
+      return OPENCODE_DESKTOP_APP_IDS.map((appId) => join11(dataHome, "applications", `${appId}.desktop`));
     }
   }
 }
@@ -12769,7 +13099,7 @@ function detectOpenCodeInstallations(deps) {
     }
   }
   for (const appId of OPENCODE_DESKTOP_APP_IDS) {
-    const marker = join10(desktopUserDataDir(d, appId), OPENCODE_DESKTOP_SETTINGS_FILE);
+    const marker = join11(desktopUserDataDir(d, appId), OPENCODE_DESKTOP_SETTINGS_FILE);
     if (d.exists(marker)) {
       addCandidate(installations, seenRealpaths, d, marker, "desktop", "desktop");
     }
@@ -12851,50 +13181,9 @@ function getAvailableModels2(binary) {
 var OPENCODE_BINARY_ENV = "MAGIC_CONTEXT_OPENCODE_BINARY", OPENCODE_VERSION_PROBE_TIMEOUT_MS = 2000;
 var init_opencode_helpers = () => {};
 
-// src/lib/opencode-plugin-cache.ts
-import { join as join11 } from "node:path";
-function getOpenCodePluginCacheRoots() {
-  const cacheDir = getOpenCodePluginCacheDir();
-  return [
-    join11(cacheDir, OPENCODE_PLUGIN_ENTRY_WITH_VERSION),
-    join11(cacheDir, OPENCODE_PLUGIN_NAME)
-  ];
-}
-function getOpenCodePluginPackageJsonPath(pluginCacheRoot) {
-  return join11(pluginCacheRoot, "node_modules", ...OPENCODE_PLUGIN_NAME.split("/"), "package.json");
-}
-function getOpenCodePluginPackageJsonPaths() {
-  return getOpenCodePluginCacheRoots().map(getOpenCodePluginPackageJsonPath);
-}
-var OPENCODE_PLUGIN_NAME = "@cortexkit/opencode-magic-context", OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
-var init_opencode_plugin_cache = __esm(() => {
-  init_paths();
-  OPENCODE_PLUGIN_ENTRY_WITH_VERSION = `${OPENCODE_PLUGIN_NAME}@latest`;
-});
-
-// src/lib/opencode-plugin-registration.ts
-function pluginConfigKeyFor(hostGeneration) {
-  return hostGeneration === "v2" ? "plugins" : "plugin";
-}
-function readPluginEntries(config) {
-  const out = [];
-  for (const key of OPENCODE_PLUGIN_CONFIG_KEYS) {
-    const list = config?.[key];
-    if (!Array.isArray(list))
-      continue;
-    for (const [index, entry] of list.entries())
-      out.push({ key, index, entry });
-  }
-  return out;
-}
-var OPENCODE_PLUGIN_CONFIG_KEYS;
-var init_opencode_plugin_registration = __esm(() => {
-  OPENCODE_PLUGIN_CONFIG_KEYS = ["plugin", "plugins"];
-});
-
 // src/adapters/opencode.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, statSync as statSync6 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute4, parse as parsePath, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync6, statSync as statSync6 } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute4, parse as parsePath, resolve as resolve4 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 class OpenCodeAdapter {
@@ -12902,21 +13191,20 @@ class OpenCodeAdapter {
   displayName = "OpenCode";
   pluginPackageName = OPENCODE_PLUGIN_NAME;
   hostGeneration;
-  resolvedWriteKey;
+  probeHostUse;
   constructor(options = {}) {
     this.hostGeneration = options.hostGeneration;
+    this.probeHostUse = options.probeHostUse;
+  }
+  get resolvedHostGeneration() {
+    if (this.hostGeneration)
+      return this.hostGeneration;
+    const detection = detectOpenCode();
+    this.hostGeneration = detection.kind === "cli" ? openCodeHostGenerationFromVersion(getOpenCodeVersion(detection.binary)) : "v1";
+    return this.hostGeneration;
   }
   get writeKey() {
-    if (this.resolvedWriteKey)
-      return this.resolvedWriteKey;
-    const generation = this.hostGeneration ?? (() => {
-      const detection = detectOpenCode();
-      if (detection.kind !== "cli")
-        return "v1";
-      return openCodeHostGenerationFromVersion(getOpenCodeVersion(detection.binary));
-    })();
-    this.resolvedWriteKey = pluginConfigKeyFor(generation);
-    return this.resolvedWriteKey;
+    return pluginConfigKeyFor(this.resolvedHostGeneration);
   }
   isInstalled() {
     return detectOpenCode().kind !== "none";
@@ -12926,7 +13214,7 @@ class OpenCodeAdapter {
     if (paths.opencodeConfigFormat === "none")
       return false;
     try {
-      const raw = readFileSync5(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync6(paths.opencodeConfig, "utf-8");
       const cfg = import_comment_json.parse(raw);
       return readPluginEntries(cfg).some(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME));
     } catch {
@@ -12962,7 +13250,7 @@ class OpenCodeAdapter {
           configPath: target
         };
       }
-      const raw = readFileSync5(target, "utf-8");
+      const raw = readFileSync6(target, "utf-8");
       const cfg = import_comment_json.parse(raw);
       if (cfg === null || typeof cfg !== "object") {
         return {
@@ -13037,7 +13325,7 @@ class OpenCodeAdapter {
       };
     }
     try {
-      const raw = readFileSync5(target, "utf-8");
+      const raw = readFileSync6(target, "utf-8");
       const cfg = import_comment_json.parse(raw);
       if (cfg === null || typeof cfg !== "object") {
         return {
@@ -13087,22 +13375,83 @@ class OpenCodeAdapter {
     return "Install OpenCode: curl -fsSL https://opencode.ai/install | bash";
   }
   getPluginCacheInfo() {
-    const path = getOpenCodePluginCacheDir();
-    return {
-      path,
-      exists: existsSync9(path),
-      sizeBytes: dirSizeBytes(path)
-    };
+    const legacyPath = getOpenCodePluginCacheDir();
+    const legacyExists = existsSync10(legacyPath);
+    const slot = getOpenCodeV2PluginCacheSlot();
+    const slotExists = existsSync10(slot);
+    const caches = [];
+    if (legacyExists || !slotExists) {
+      caches.push({
+        path: legacyPath,
+        exists: legacyExists,
+        sizeBytes: dirSizeBytes(legacyPath),
+        label: "OpenCode 1 plugin packages"
+      });
+    }
+    if (slotExists) {
+      caches.push({
+        path: slot,
+        exists: true,
+        sizeBytes: dirSizeBytes(slot),
+        label: "OpenCode 2 Magic Context @latest install",
+        clear: () => this.clearOpenCodeV2Slot(slot)
+      });
+    }
+    return caches;
+  }
+  clearOpenCodeV2Slot(slot) {
+    let databases;
+    try {
+      databases = [
+        ...new Set([resolveOpenCodeDbPath("v1").path, resolveOpenCodeDbPath("v2").path])
+      ];
+    } catch (err) {
+      return {
+        cleared: false,
+        reason: `could not locate the OpenCode database to check whether OpenCode is running (${err instanceof Error ? err.message : String(err)})`
+      };
+    }
+    const removal = removeOpenCodeV2PluginCacheSlot(slot, openCodeHostDatabaseFiles(databases), {
+      probe: this.probeHostUse
+    });
+    switch (removal.action) {
+      case "cleared":
+        return { cleared: true };
+      case "in_use":
+        return {
+          cleared: false,
+          reason: `OpenCode is running (pid ${removal.pids.join(", ")}); quit it (and \`opencode service stop\`) first`
+        };
+      case "in_use_unknown":
+        return { cleared: false, reason: removal.reason };
+      case "error":
+        return { cleared: false, reason: removal.error };
+    }
   }
   getLogPath() {
     return getMagicContextLogPath2("opencode");
   }
+  configuredPluginSpec() {
+    const paths = detectConfigPaths();
+    if (paths.opencodeConfigFormat === "none")
+      return "latest";
+    try {
+      const cfg = import_comment_json.parse(readFileSync6(paths.opencodeConfig, "utf-8"));
+      return readConfiguredOpenCodePluginSpec(cfg);
+    } catch {
+      return "latest";
+    }
+  }
   getInstalledPluginVersion() {
+    if (this.resolvedHostGeneration === "v2") {
+      const slot = getOpenCodeV2PluginCacheSlot(undefined, this.configuredPluginSpec());
+      return readOpenCodeV2CachedPluginVersion(slot) ?? null;
+    }
     for (const candidate of getOpenCodePluginPackageJsonPaths()) {
-      if (!existsSync9(candidate))
+      if (!existsSync10(candidate))
         continue;
       try {
-        const raw = readFileSync5(candidate, "utf-8");
+        const raw = readFileSync6(candidate, "utf-8");
         const pkg = JSON.parse(raw);
         if (typeof pkg.version === "string")
           return pkg.version;
@@ -13138,15 +13487,15 @@ function isDevPathPluginEntry(entry) {
     if (candidate.startsWith("file://")) {
       localPath = fileURLToPath(candidate);
     } else {
-      localPath = resolve3(candidate);
+      localPath = resolve4(candidate);
     }
     if (statSync6(localPath).isFile())
       localPath = dirname4(localPath);
     const root = parsePath(localPath).root;
     while (localPath !== root) {
-      const packagePath = resolve3(localPath, "package.json");
-      if (existsSync9(packagePath)) {
-        const pkg = JSON.parse(readFileSync5(packagePath, "utf8"));
+      const packagePath = resolve4(localPath, "package.json");
+      if (existsSync10(packagePath)) {
+        const pkg = JSON.parse(readFileSync6(packagePath, "utf8"));
         return pkg.name === OPENCODE_PLUGIN_NAME;
       }
       localPath = dirname4(localPath);
@@ -13166,7 +13515,7 @@ function matchesPluginEntry(entry, pkgName) {
 }
 function ensureDir(filePath) {
   const dir = dirname4(filePath);
-  if (!existsSync9(dir)) {
+  if (!existsSync10(dir)) {
     const { mkdirSync } = __require("node:fs");
     mkdirSync(dir, { recursive: true });
   }
@@ -13174,6 +13523,7 @@ function ensureDir(filePath) {
 var import_comment_json;
 var init_opencode = __esm(() => {
   init_opencode_db_path();
+  init_doctor_opencode2_cache();
   init_atomic_write();
   init_opencode_detect();
   init_opencode_helpers();
@@ -13184,7 +13534,7 @@ var init_opencode = __esm(() => {
 });
 
 // ../plugin/src/shared/jsonc-parser.ts
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
 function stripJsonComments(content) {
   let result = "";
   let inString = false;
@@ -13359,7 +13709,7 @@ function parseJsonc2(content, options = {}) {
 }
 function readJsoncFile(filePath) {
   try {
-    return parseJsonc2(readFileSync6(filePath, "utf-8"));
+    return parseJsonc2(readFileSync7(filePath, "utf-8"));
   } catch (_error) {
     return null;
   }
@@ -13367,10 +13717,10 @@ function readJsoncFile(filePath) {
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync10(jsoncPath)) {
+  if (existsSync11(jsoncPath)) {
     return { format: "jsonc", path: jsoncPath };
   }
-  if (existsSync10(jsonPath)) {
+  if (existsSync11(jsonPath)) {
     return { format: "json", path: jsonPath };
   }
   return { format: "none", path: jsoncPath };
@@ -13382,7 +13732,7 @@ var init_jsonc_parser = __esm(() => {
 });
 
 // src/lib/jsonc-config.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
 function parseErrorLocation(content, error) {
   const lines = content.split(`
 `);
@@ -13398,9 +13748,9 @@ function parseErrorLocation(content, error) {
   return { line: messageLine ? Number.parseInt(messageLine, 10) : 1, column: 1 };
 }
 function readJsoncConfig(path) {
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return { kind: "missing" };
-  const content = readFileSync7(path, "utf-8");
+  const content = readFileSync8(path, "utf-8");
   try {
     const rejectedKeyPaths = [];
     const parsed = sanitizeParsedJson(import_comment_json2.parse(content), {
@@ -13449,7 +13799,7 @@ var init_jsonc_config = __esm(() => {
 });
 
 // src/lib/pi-package-entry.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync9 } from "node:fs";
 import { isAbsolute as isAbsolute5, join as join12 } from "node:path";
 function stripNpmPrefix(value) {
   return value.startsWith("npm:") ? value.slice("npm:".length) : value;
@@ -13506,10 +13856,10 @@ function hasPiMagicContextPackage(entries, agentDir = getPiAgentConfigDir()) {
 }
 function isPiMagicContextPackageDir(dir) {
   const packageJson = join12(dir, "package.json");
-  if (!existsSync12(packageJson))
+  if (!existsSync13(packageJson))
     return false;
   try {
-    const pkg = JSON.parse(readFileSync8(packageJson, "utf-8"));
+    const pkg = JSON.parse(readFileSync9(packageJson, "utf-8"));
     return typeof pkg.name === "string" && pkg.name === PI_MAGIC_CONTEXT_PACKAGE_NAME;
   } catch {
     return false;
@@ -13545,7 +13895,7 @@ var init_pi_package_entry = __esm(() => {
 });
 
 // src/adapters/pi.ts
-import { existsSync as existsSync13 } from "node:fs";
+import { existsSync as existsSync14 } from "node:fs";
 import { dirname as dirname5 } from "node:path";
 
 class PiAdapter {
@@ -13647,7 +13997,7 @@ class PiAdapter {
     return "Install Pi: https://pi.coding/install (npm: @earendil-works/pi-coding-agent)";
   }
   getPluginCacheInfo() {
-    return { path: null, exists: false, sizeBytes: 0 };
+    return [{ path: null, exists: false, sizeBytes: 0 }];
   }
   getLogPath() {
     return getMagicContextLogPath2("pi");
@@ -13684,7 +14034,7 @@ function writePiSettings(settings) {
 }
 function ensureDir2(filePath) {
   const dir = dirname5(filePath);
-  if (!existsSync13(dir)) {
+  if (!existsSync14(dir)) {
     const { mkdirSync } = __require("node:fs");
     mkdirSync(dir, { recursive: true });
   }
@@ -13814,10 +14164,10 @@ var init_harness_provider_map = __esm(() => {
 // ../plugin/src/config/raw-loader.ts
 import {
   closeSync as closeSync2,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   linkSync,
   openSync as openSync2,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   renameSync as renameSync3,
   statSync as statSync7,
   unlinkSync as unlinkSync2,
@@ -14017,7 +14367,7 @@ function writeExclusiveBackup(backupPath, bytes, mode) {
       if (error.code !== "EEXIST")
         throw error;
     }
-    const existingBytes = readFileSync9(backupPath);
+    const existingBytes = readFileSync10(backupPath);
     if (existingBytes.equals(bytes))
       return;
     if (bytes.subarray(0, existingBytes.length).equals(existingBytes)) {
@@ -14061,11 +14411,11 @@ function migrationWarning(diagnostic) {
   return diagnostic.message;
 }
 function loadRawConfigFile(options) {
-  if (!existsSync14(options.configPath))
+  if (!existsSync15(options.configPath))
     return null;
   let observedBytes;
   try {
-    observedBytes = readFileSync9(options.configPath);
+    observedBytes = readFileSync10(options.configPath);
   } catch (error) {
     throw new Error(`failed to read config: ${error instanceof Error ? error.message : String(error)}`);
   }
@@ -14109,7 +14459,7 @@ function loadRawConfigFile(options) {
       writeExclusiveBackup(backupPath, observedBytes, mode);
       temporaryPath = writeTemporaryCandidate(options.configPath, migration.bytes, mode);
       options.afterTemporaryWrite?.();
-      const currentBytes = readFileSync9(options.configPath);
+      const currentBytes = readFileSync10(options.configPath);
       if (!hasFlatKeys(currentBytes)) {
         unlinkSync2(temporaryPath);
         return {
@@ -14481,10 +14831,10 @@ var init_dreamer_setup = __esm(() => {
 });
 
 // src/commands/setup-pi.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync3 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
 function ensureDir3(path) {
-  if (!existsSync15(path))
+  if (!existsSync16(path))
     mkdirSync3(path, { recursive: true });
 }
 async function getDefaultPrompts() {
@@ -21910,16 +22260,16 @@ function resolveTransformMode(args) {
 var RUST_COMPACTION_OFF_WARNING = "compaction-off mode does not support rust transform mode; using the TypeScript transform.", RUST_REQUIRES_USER_SUBC_WARNING = "rust mode requires user-level subc configuration; running ts.";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync16, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync17, readFileSync as readFileSync11 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { dirname as dirname9, isAbsolute as isAbsolute6, resolve as resolve4 } from "node:path";
+import { dirname as dirname9, isAbsolute as isAbsolute6, resolve as resolve5 } from "node:path";
 function sensitiveFilePathReason(resolvedPath) {
   const home = homedir10();
   const sensitiveDirs = [
-    { dir: resolve4(home, ".ssh"), label: "SSH keys" },
-    { dir: resolve4(home, ".aws"), label: "AWS credentials" },
-    { dir: resolve4(home, ".gnupg"), label: "GnuPG keyring" },
-    { dir: resolve4(home, ".config", "gh"), label: "GitHub CLI auth" }
+    { dir: resolve5(home, ".ssh"), label: "SSH keys" },
+    { dir: resolve5(home, ".aws"), label: "AWS credentials" },
+    { dir: resolve5(home, ".gnupg"), label: "GnuPG keyring" },
+    { dir: resolve5(home, ".config", "gh"), label: "GitHub CLI auth" }
   ];
   for (const { dir, label } of sensitiveDirs) {
     if (resolvedPath === dir || resolvedPath.startsWith(`${dir}/`)) {
@@ -21977,21 +22327,21 @@ function substituteConfigVariables(input) {
     }
     let filePath = rawPath.trim();
     if (filePath.startsWith("~/")) {
-      filePath = resolve4(homedir10(), filePath.slice(2));
+      filePath = resolve5(homedir10(), filePath.slice(2));
     } else if (!isAbsolute6(filePath)) {
-      filePath = resolve4(configDir, filePath);
+      filePath = resolve5(configDir, filePath);
     }
     const sensitiveReason = sensitiveFilePathReason(filePath);
     if (sensitiveReason) {
       warnings.push(`${token} resolves to a sensitive path (${sensitiveReason}: ${filePath}); ` + "inlining its contents into config — make sure this is intentional.");
     }
-    if (!existsSync16(filePath)) {
+    if (!existsSync17(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
     let contents;
     try {
-      contents = readFileSync10(filePath, "utf-8").trim();
+      contents = readFileSync11(filePath, "utf-8").trim();
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
@@ -22010,7 +22360,7 @@ var init_variable = __esm(() => {
 });
 
 // ../plugin/src/config/index.ts
-import { existsSync as existsSync17 } from "node:fs";
+import { existsSync as existsSync18 } from "node:fs";
 function getUserConfigBasePath() {
   return cortexKitUserConfigBasePath();
 }
@@ -22018,10 +22368,10 @@ function getProjectConfigBasePath(directory) {
   return cortexKitProjectConfigBasePath(directory);
 }
 function resolveLegacyReadFallback(sources) {
-  return { source: sources.find((s) => existsSync17(s.path)) ?? null };
+  return { source: sources.find((s) => existsSync18(s.path)) ?? null };
 }
 function loadConfigFileDetailed(configPath, source) {
-  if (!existsSync17(configPath)) {
+  if (!existsSync18(configPath)) {
     return null;
   }
   let rawText;
@@ -22334,8 +22684,8 @@ function loadPluginConfigDetailed(directory, applyRuntimeGlobals = true) {
   const harnessLegacy = resolveLegacyConfigSourcesForHarness(directory, "opencode");
   const userLegacyFallback = userDetected.format === "none" ? resolveLegacyReadFallback(harnessLegacy.user) : { source: null };
   const projectLegacyFallback = projectDetected.format === "none" ? resolveLegacyReadFallback(harnessLegacy.project) : { source: null };
-  const legacyUserUnmigrated = userDetected.format === "none" && !userLegacyFallback.source && legacySources.user.some((source) => existsSync17(source.path));
-  const legacyProjectUnmigrated = projectDetected.format === "none" && !projectLegacyFallback.source && legacySources.project.some((source) => existsSync17(source.path));
+  const legacyUserUnmigrated = userDetected.format === "none" && !userLegacyFallback.source && legacySources.user.some((source) => existsSync18(source.path));
+  const legacyProjectUnmigrated = projectDetected.format === "none" && !projectLegacyFallback.source && legacySources.project.some((source) => existsSync18(source.path));
   const userLoaded = userDetected.format !== "none" ? loadConfigFileDetailed(userDetected.path, "user") : userLegacyFallback.source ? loadConfigFileDetailed(userLegacyFallback.source.path, "user") : null;
   const projectLoaded = projectDetected.format !== "none" ? loadConfigFileDetailed(projectDetected.path, "project") : projectLegacyFallback.source ? loadConfigFileDetailed(projectLegacyFallback.source.path, "project") : null;
   const allWarnings = [];
@@ -22473,7 +22823,7 @@ var init_config = __esm(() => {
 
 // ../plugin/src/shared/opencode-config-dir.ts
 import { homedir as homedir11 } from "node:os";
-import { join as join14, resolve as resolve5 } from "node:path";
+import { join as join14, resolve as resolve6 } from "node:path";
 function resolveHomeDir() {
   return process.env.HOME?.trim() || homedir11();
 }
@@ -22485,7 +22835,7 @@ function getOpenCodeGlobalConfigDir() {
 }
 function getEnvConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  return envConfigDir ? resolve5(envConfigDir) : undefined;
+  return envConfigDir ? resolve6(envConfigDir) : undefined;
 }
 function getCliConfigDir() {
   return getEnvConfigDir() ?? getOpenCodeGlobalConfigDir();
@@ -22772,7 +23122,7 @@ var init_conflict_detector = __esm(() => {
 });
 
 // ../plugin/src/shared/conflict-fixer.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync12, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 import { join as join16 } from "node:path";
 function isRecord2(value) {
@@ -22782,11 +23132,11 @@ function asStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function readConfig(filePath) {
-  if (!existsSync18(filePath)) {
+  if (!existsSync19(filePath)) {
     return null;
   }
   try {
-    const text = readFileSync11(filePath, "utf-8");
+    const text = readFileSync12(filePath, "utf-8");
     const parsed = import_comment_json5.parse(text);
     return isRecord2(parsed) ? { config: parsed, text } : null;
   } catch {
@@ -22798,14 +23148,14 @@ function writeConfig(filePath, text) {
 }
 function resolveUserOpenCodeConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-  if (existsSync18(paths.configJsonc))
+  if (existsSync19(paths.configJsonc))
     return paths.configJsonc;
   return paths.configJson;
 }
 function collectOpenCodeConfigPaths(directory) {
   const paths = new Set;
   const userConfig = resolveUserOpenCodeConfigPath();
-  if (existsSync18(userConfig)) {
+  if (existsSync19(userConfig)) {
     paths.add(userConfig);
   }
   for (const filePath of [
@@ -22814,7 +23164,7 @@ function collectOpenCodeConfigPaths(directory) {
     join16(directory, "opencode.jsonc"),
     join16(directory, "opencode.json")
   ]) {
-    if (existsSync18(filePath)) {
+    if (existsSync19(filePath)) {
       paths.add(filePath);
     }
   }
@@ -22826,10 +23176,10 @@ function collectOmoConfigPaths(directory) {
   for (const fileName of OMO_CONFIG_NAMES) {
     const userPath = join16(configDir, fileName);
     const projectPath = join16(directory, fileName);
-    if (existsSync18(userPath)) {
+    if (existsSync19(userPath)) {
       paths.add(userPath);
     }
-    if (existsSync18(projectPath)) {
+    if (existsSync19(projectPath)) {
       paths.add(projectPath);
     }
   }
@@ -22837,13 +23187,13 @@ function collectOmoConfigPaths(directory) {
   const omoHomeDir = join16(homeDir, ".omo");
   for (const name of OMO_UNIFIED_NAMES) {
     const userPath = join16(omoHomeDir, name);
-    if (existsSync18(userPath)) {
+    if (existsSync19(userPath)) {
       paths.add(userPath);
     }
   }
   for (const name of OMO_UNIFIED_NAMES) {
     const projectPath = join16(directory, ".omo", name);
-    if (existsSync18(projectPath)) {
+    if (existsSync19(projectPath)) {
       paths.add(projectPath);
     }
   }
@@ -22971,7 +23321,7 @@ var init_conflict_fixer = __esm(() => {
 });
 
 // src/commands/setup-opencode.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync5, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync5, readFileSync as readFileSync13 } from "node:fs";
 import { basename as basename3, dirname as dirname10 } from "node:path";
 function resolveCompactionEnabledForWriter() {
   try {
@@ -22983,7 +23333,7 @@ function resolveCompactionEnabledForWriter() {
   }
 }
 function ensureDir5(dir) {
-  if (!existsSync19(dir)) {
+  if (!existsSync20(dir)) {
     mkdirSync5(dir, { recursive: true });
   }
 }
@@ -23012,7 +23362,7 @@ function readMagicContextConfigForSetup2(configPath) {
 }
 function addPluginToOpenCodeConfig(configPath, _format, removeDcp = false, compactionEnabled = true, hostGeneration = "v1") {
   const registrationKey = pluginConfigKeyFor(hostGeneration);
-  const existsAtCommit = existsSync19(configPath);
+  const existsAtCommit = existsSync20(configPath);
   const existing = existsAtCommit ? readJsoncConfigForUpdate(configPath) : {};
   if (!existsAtCommit) {
     ensureDir5(dirname10(configPath));
@@ -23024,7 +23374,7 @@ function addPluginToOpenCodeConfig(configPath, _format, removeDcp = false, compa
 `);
     return;
   }
-  let text = readFileSync12(configPath, "utf-8");
+  let text = readFileSync13(configPath, "utf-8");
   let changed = false;
   const rawPlugins = readPluginEntries(existing).map(({ entry }) => entry);
   const retainedPlugins = removeDcp ? rawPlugins.filter((plugin) => !matchesPluginEntry(plugin, DCP_PLUGIN_NAME)) : rawPlugins;
@@ -23070,7 +23420,7 @@ function addPluginToOpenCodeConfig(configPath, _format, removeDcp = false, compa
     writeFileAtomic(configPath, text);
 }
 function addPluginToTuiConfig(configPath, _format) {
-  const existsAtCommit = existsSync19(configPath);
+  const existsAtCommit = existsSync20(configPath);
   const existing = existsAtCommit ? readJsoncConfigForUpdate(configPath) : {};
   if (!existsAtCommit) {
     ensureDir5(dirname10(configPath));
@@ -23086,7 +23436,7 @@ function addPluginToTuiConfig(configPath, _format) {
   const hasDevEntry = rawPlugins.some((plugin) => isDevPathPluginEntry(plugin));
   if (hasNpmEntry || hasDevEntry)
     return;
-  const text = Array.isArray(existing.plugin) ? appendJsoncArrayValues(readFileSync12(configPath, "utf-8"), ["plugin"], [OPENCODE_PLUGIN_ENTRY_WITH_VERSION]) : setJsoncValue(readFileSync12(configPath, "utf-8"), ["plugin"], [OPENCODE_PLUGIN_ENTRY_WITH_VERSION]);
+  const text = Array.isArray(existing.plugin) ? appendJsoncArrayValues(readFileSync13(configPath, "utf-8"), ["plugin"], [OPENCODE_PLUGIN_ENTRY_WITH_VERSION]) : setJsoncValue(readFileSync13(configPath, "utf-8"), ["plugin"], [OPENCODE_PLUGIN_ENTRY_WITH_VERSION]);
   writeFileAtomic(configPath, text);
 }
 function findDcpPluginIndexes(plugins) {
@@ -23192,7 +23542,7 @@ async function runSetup3(dryRun = false) {
     log2.warn("You can configure models manually in magic-context.jsonc later");
   }
   const paths = detectConfigPaths();
-  const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync19(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
+  const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync20(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
   if (!dryRun) {
     try {
       assertJsoncConfigsParseable([
@@ -24482,7 +24832,7 @@ var init_context_authority = __esm(async () => {
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync20, realpathSync as realpathSync2, statSync as statSync9 } from "node:fs";
+import { existsSync as existsSync21, realpathSync as realpathSync2, statSync as statSync9 } from "node:fs";
 import path3 from "node:path";
 function asError(error) {
   return error instanceof Error ? error : undefined;
@@ -24720,7 +25070,7 @@ function hasGitDir(canonical) {
 function gitRootInAncestorChain(startDirectory) {
   let current = startDirectory;
   while (true) {
-    if (existsSync20(path3.join(current, ".git"))) {
+    if (existsSync21(path3.join(current, ".git"))) {
       try {
         return realpathSync2.native(current);
       } catch {
@@ -27055,7 +27405,7 @@ var init_pi_executable = __esm(() => {
 
 // ../plugin/src/shared/rpc-utils.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return "dead";
@@ -27591,7 +27941,7 @@ var init_rpc_utils = __esm(() => {
     "cljs/dist",
     "dist/bundle/cli"
   ];
-  rpcIdentityReadFileSync = readFileSync13;
+  rpcIdentityReadFileSync = readFileSync14;
   rpcIdentityExecFileSync = execFileSync4;
   rpcIdentityProcessKill = process.kill;
   rpcProcessListExecFileSync = execFileSync4;
@@ -30883,14 +31233,14 @@ import {
   chmodSync as chmodSync3,
   copyFileSync,
   cpSync,
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync6,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync14,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync15,
   statSync as statSync10,
   unlinkSync as unlinkSync3
 } from "node:fs";
-import { basename as basename4, dirname as dirname11, join as join18, resolve as resolve6 } from "node:path";
+import { basename as basename4, dirname as dirname11, join as join18, resolve as resolve7 } from "node:path";
 function resolveBootBusyTimeoutMs(value) {
   if (value === undefined)
     return BOOT_SQLITE_BUSY_TIMEOUT_MS;
@@ -32329,8 +32679,8 @@ var init_storage_db = __esm(async () => {
   PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
   RPC_DISCOVERY_PARSE_GRACE_MS = 10 * 60 * 1000;
   defaultRpcDiscoveryFs = {
-    readdirSync: (path, options) => options?.withFileTypes ? readdirSync3(path, { withFileTypes: true }) : readdirSync3(path),
-    readFileSync: (path, encoding) => String(readFileSync14(path, encoding)),
+    readdirSync: (path, options) => options?.withFileTypes ? readdirSync4(path, { withFileTypes: true }) : readdirSync4(path),
+    readFileSync: (path, encoding) => String(readFileSync15(path, encoding)),
     statSync: (path) => ({ mtimeMs: statSync10(path).mtimeMs }),
     unlinkSync: (path) => unlinkSync3(path)
   };
@@ -32343,13 +32693,13 @@ var init_storage_db = __esm(async () => {
 });
 
 // src/lib/database-access.ts
-import { existsSync as existsSync22, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync23, writeFileSync as writeFileSync5 } from "node:fs";
 import { pathToFileURL } from "node:url";
 function getPersistedSchemaVersion2(db) {
   return getPersistedSchemaVersion(db);
 }
 function openExistingDatabase(path, options) {
-  if (!existsSync22(path))
+  if (!existsSync23(path))
     return null;
   if (options.readonly) {
     const db = new Database(path, { readonly: true });
@@ -32960,16 +33310,16 @@ var init_doctor_merge_identity = __esm(async () => {
 });
 
 // src/commands/doctor-repair-db.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 import {
   chmodSync as chmodSync4,
   closeSync as closeSync4,
   constants as constants2,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   openSync as openSync4,
   renameSync as renameSync4,
-  rmSync as rmSync2,
+  rmSync as rmSync3,
   statSync as statSync11
 } from "node:fs";
 import { dirname as dirname12, join as join20 } from "node:path";
@@ -33002,11 +33352,11 @@ function timestamp(date) {
   return date.toISOString().replaceAll("-", "").replaceAll(":", "").replace(".", "");
 }
 function uniqueBase(preferred) {
-  if (!DATABASE_SUFFIXES.some((suffix) => existsSync23(`${preferred}${suffix}`)))
+  if (!DATABASE_SUFFIXES.some((suffix) => existsSync24(`${preferred}${suffix}`)))
     return preferred;
   for (let attempt = 1;attempt < 1e4; attempt++) {
     const candidate = `${preferred}-${attempt}`;
-    if (!DATABASE_SUFFIXES.some((suffix) => existsSync23(`${candidate}${suffix}`)))
+    if (!DATABASE_SUFFIXES.some((suffix) => existsSync24(`${candidate}${suffix}`)))
       return candidate;
   }
   throw new Error(`Could not allocate a unique recovery path beside ${preferred}`);
@@ -33020,7 +33370,7 @@ function copyDatabaseBundle(sourceBase, destinationBase) {
   const copiedPaths = [];
   for (const suffix of DATABASE_SUFFIXES) {
     const source = `${sourceBase}${suffix}`;
-    if (!existsSync23(source))
+    if (!existsSync24(source))
       continue;
     const destination = `${destinationBase}${suffix}`;
     copyFileSync2(source, destination, constants2.COPYFILE_EXCL);
@@ -33088,7 +33438,7 @@ function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath)
   let dumpWriteFd = null;
   try {
     dumpWriteFd = openSync4(dumpPath, "wx", 384);
-    const recovered = spawnSync3(sqliteExecutable, [sourcePath, ".recover"], {
+    const recovered = spawnSync4(sqliteExecutable, [sourcePath, ".recover"], {
       stdio: ["ignore", dumpWriteFd, "pipe"],
       encoding: "utf8",
       windowsHide: true
@@ -33107,7 +33457,7 @@ function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath)
     }
     const dumpReadFd = openSync4(dumpPath, "r");
     try {
-      const replayed = spawnSync3(sqliteExecutable, [recoveredPath], {
+      const replayed = spawnSync4(sqliteExecutable, [recoveredPath], {
         stdio: [dumpReadFd, "ignore", "pipe"],
         encoding: "utf8",
         windowsHide: true
@@ -33134,7 +33484,7 @@ function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath)
   } finally {
     if (dumpWriteFd !== null)
       closeSync4(dumpWriteFd);
-    rmSync2(dumpPath, { force: true });
+    rmSync3(dumpPath, { force: true });
   }
 }
 function migrateAndCheckRecoveredDatabase(path) {
@@ -33213,14 +33563,14 @@ function prepareFreshDatabase(path) {
 }
 function removeRecoveryBundle(basePath) {
   for (const suffix of DATABASE_SUFFIXES)
-    rmSync2(`${basePath}${suffix}`, { force: true });
+    rmSync3(`${basePath}${suffix}`, { force: true });
 }
 function activateReplacement(dbPath, replacementPath, originalAsidePath) {
   const movedOriginals = [];
   try {
     for (const suffix of DATABASE_SUFFIXES) {
       const from = `${dbPath}${suffix}`;
-      if (!existsSync23(from))
+      if (!existsSync24(from))
         continue;
       const to = `${originalAsidePath}${suffix}`;
       renameSync4(from, to);
@@ -33230,7 +33580,7 @@ function activateReplacement(dbPath, replacementPath, originalAsidePath) {
     return movedOriginals.map(({ to }) => to);
   } catch (error) {
     for (const moved of movedOriginals.reverse()) {
-      if (existsSync23(moved.to) && !existsSync23(moved.from))
+      if (existsSync24(moved.to) && !existsSync24(moved.from))
         renameSync4(moved.to, moved.from);
     }
     throw error;
@@ -33266,7 +33616,7 @@ async function runRepairDb(options = {}) {
   const stamp = timestamp(deps.now());
   prompts.intro("Magic Context — Repair shared database");
   prompts.log.info(`Database: ${dbPath}`);
-  if (!existsSync23(dbPath)) {
+  if (!existsSync24(dbPath)) {
     prompts.log.error(`Database not found: ${dbPath}`);
     prompts.log.info("Backup: not created (database does not exist)");
     prompts.outro("Database repair failed");
@@ -33553,7 +33903,7 @@ var init_migration_paths = __esm(() => {
 
 // src/commands/migrate.ts
 import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
-import { existsSync as existsSync24, mkdirSync as mkdirSync7, renameSync as renameSync5, unlinkSync as unlinkSync4 } from "node:fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync7, renameSync as renameSync5, unlinkSync as unlinkSync4 } from "node:fs";
 import { dirname as dirname13, join as join21 } from "node:path";
 function defaultOpenCodeDbPath() {
   return getOpenCodeDatabasePath();
@@ -33565,7 +33915,7 @@ function defaultPiSessionsRoot() {
   return getPiSessionsRoot();
 }
 function defaultFs() {
-  return { writeFileAtomic, unlinkSync: unlinkSync4, existsSync: existsSync24, renameSync: renameSync5, mkdirSync: mkdirSync7 };
+  return { writeFileAtomic, unlinkSync: unlinkSync4, existsSync: existsSync25, renameSync: renameSync5, mkdirSync: mkdirSync7 };
 }
 function stmt(db, sql) {
   return db.prepare(sql);
@@ -34513,7 +34863,7 @@ var init_relocate_memory = __esm(() => {
 });
 
 // src/commands/migrate-session.ts
-import { existsSync as existsSync25, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync26, realpathSync as realpathSync4 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 import path4, { join as join22 } from "node:path";
 function existingSessionColumns(db) {
@@ -34732,7 +35082,7 @@ function realDeps(opencodeDb, contextDb) {
     opencodeDb,
     contextDb,
     resolveIdentity: resolveProjectIdentity,
-    hasGitDir: (dir) => existsSync25(join22(dir, ".git")),
+    hasGitDir: (dir) => existsSync26(join22(dir, ".git")),
     realpath: (p) => realpathSync4(p)
   };
 }
@@ -34811,7 +35161,7 @@ async function runMigrateSessionCli(args) {
     return 1;
   }
   const expandedTo = toDir.startsWith("~") ? join22(homedir14(), toDir.slice(1).replace(/^[/\\]/, "")) : toDir;
-  if (!existsSync25(expandedTo)) {
+  if (!existsSync26(expandedTo)) {
     console.error(`Target directory does not exist: ${expandedTo}`);
     return 1;
   }
@@ -35213,6 +35563,11 @@ var init_user_facing_codes = __esm(() => {
       sentence: "Some finished background sessions could not be removed from this host.",
       action: "They are removed automatically the next time Magic Context runs inside a registered OpenCode service."
     },
+    historian_saved_history_misaligned: {
+      code: "MC-H03",
+      sentence: "History compression is paused because this session's saved summaries no longer line up with its messages.",
+      action: "Run /ctx-recomp to rebuild them."
+    },
     recomp_unavailable: {
       code: "MC-R01",
       sentence: "History compression could not be rebuilt.",
@@ -35383,6 +35738,11 @@ var init_user_facing_codes = __esm(() => {
       sentence: "History compression is paused while the engine syncs.",
       action: "Retry in a moment."
     },
+    history_compression_needs_message: {
+      code: "MC-C12",
+      sentence: "History compression has not seen this session since Magic Context reconnected.",
+      action: "Send a message in this session first, then run /ctx-wrapup again."
+    },
     context_service_unavailable: {
       code: "MC-C10",
       sentence: "Magic Context is temporarily unavailable.",
@@ -35453,7 +35813,7 @@ var init_tick_failure = __esm(() => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 function getProjectConfigPaths(cwd) {
   const basePath = cortexKitProjectConfigBasePath(cwd);
   return [`${basePath}.jsonc`, `${basePath}.json`];
@@ -35463,10 +35823,10 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path) => existsSync26(path));
+  return paths.find((path) => existsSync27(path));
 }
 function resolvePiLegacyFallback(sources) {
-  return sources.find((source) => existsSync26(source.path)) ?? null;
+  return sources.find((source) => existsSync27(source.path)) ?? null;
 }
 function loadConfigFile(path, scope) {
   let raw;
@@ -35761,7 +36121,7 @@ function loadPiConfigDetailed(opts = {}, applyRuntimeGlobals = true) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync26(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync27(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -35770,7 +36130,7 @@ function loadPiConfigDetailed(opts = {}, applyRuntimeGlobals = true) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync26(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync27(source.path));
   if (userLegacyFallback) {
     warnings.push(`[user config] reading legacy config from ${userLegacyFallback.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
   } else if (legacyUserUnmigrated) {
@@ -35891,11 +36251,11 @@ function formatDatabaseRepairGuidance(dbPath) {
 var DATABASE_REPAIR_COMMAND = "bunx @cortexkit/magic-context@latest doctor repair-db";
 
 // src/lib/github-issue.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { readFileSync as readFileSync15 } from "node:fs";
+import { spawnSync as spawnSync5 } from "node:child_process";
+import { readFileSync as readFileSync16 } from "node:fs";
 function runGhCommand(args) {
   try {
-    const result = spawnSync4("gh", args, {
+    const result = spawnSync5("gh", args, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -35918,7 +36278,7 @@ function failed(result) {
 function submitGithubIssue(title, bodyPath, runner = runGhCommand) {
   let body;
   try {
-    body = readFileSync15(bodyPath, "utf-8");
+    body = readFileSync16(bodyPath, "utf-8");
   } catch (error) {
     return {
       ok: false,
@@ -35976,7 +36336,7 @@ var MAX_GITHUB_ISSUE_BODY_CHARS = 65536;
 var init_github_issue = () => {};
 
 // src/lib/log-lines.ts
-import { existsSync as existsSync27, readFileSync as readFileSync16, statSync as statSync12 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync17, statSync as statSync12 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join23 } from "node:path";
 function tokenize(input, limit = Number.POSITIVE_INFINITY) {
@@ -36273,11 +36633,11 @@ function getMagicContextLogPaths(harness, options = {}) {
   ].filter((path, index, paths) => paths.indexOf(path) === index);
 }
 function inspectLogFile(path) {
-  if (!existsSync27(path)) {
+  if (!existsSync28(path)) {
     return { path, exists: false, sizeKb: 0, lineCount: 0, grammar: "unknown" };
   }
   try {
-    const content = readFileSync16(path, "utf8");
+    const content = readFileSync17(path, "utf8");
     const lines = content.split(/\r?\n/).filter((line) => line.length > 0);
     const grammars = new Set(lines.flatMap((line) => {
       const parsed = parseLogLine(line);
@@ -36304,7 +36664,7 @@ function readLogLines(files) {
       return [];
     try {
       let precedingTimestamp = "";
-      return readFileSync16(file.path, "utf8").split(/\r?\n/).filter((line) => line.length > 0).map((line, lineIndex) => {
+      return readFileSync17(file.path, "utf8").split(/\r?\n/).filter((line) => line.length > 0).map((line, lineIndex) => {
         precedingTimestamp = parseLogLine(line)?.ts ?? precedingTimestamp;
         return { line, timestamp: precedingTimestamp, fileIndex, lineIndex };
       });
@@ -36353,10 +36713,10 @@ var init_redaction2 = __esm(() => {
 });
 
 // src/commands/doctor-omp.ts
-import { execFileSync as execFileSync5, spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync28, mkdirSync as mkdirSync8, readFileSync as readFileSync17 } from "node:fs";
+import { execFileSync as execFileSync5, spawnSync as spawnSync6 } from "node:child_process";
+import { existsSync as existsSync29, mkdirSync as mkdirSync8, readFileSync as readFileSync18 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname14, join as join24, resolve as resolve7 } from "node:path";
+import { dirname as dirname14, join as join24, resolve as resolve8 } from "node:path";
 function parseSemver(value) {
   const match = value?.match(/(\d+)\.(\d+)\.(\d+)/);
   return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
@@ -36398,10 +36758,10 @@ function selfVersion() {
   return "unknown";
 }
 function readConfig2(path) {
-  if (!existsSync28(path))
+  if (!existsSync29(path))
     return {};
   try {
-    const parsed = import_comment_json7.parse(readFileSync17(path, "utf-8"));
+    const parsed = import_comment_json7.parse(readFileSync18(path, "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? {} : { error: "top level is not an object" };
   } catch (error) {
     return { error: error instanceof Error ? error.message : String(error) };
@@ -36411,7 +36771,7 @@ function pluginDeclaresOmp(path) {
   if (!path)
     return null;
   try {
-    const pkg = JSON.parse(readFileSync17(join24(path, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync18(join24(path, "package.json"), "utf-8"));
     return Array.isArray(pkg.omp?.extensions) || Array.isArray(pkg.pi?.extensions);
   } catch {
     return null;
@@ -36482,8 +36842,8 @@ async function runHealthChecks(options) {
     if (!reportedAgentDir.ok) {
       add(results, "warn", "Could not verify OMP active agent directory");
     } else {
-      const reportedPath = resolve7(reportedAgentDir.stdout);
-      const expectedPath = resolve7(getOmpAgentDir());
+      const reportedPath = resolve8(reportedAgentDir.stdout);
+      const expectedPath = resolve8(getOmpAgentDir());
       if (reportedPath === expectedPath) {
         add(results, "pass", `OMP agent directory resolved to ${getOmpAgentDir()}`);
       } else {
@@ -36492,7 +36852,7 @@ async function runHealthChecks(options) {
     }
   }
   const userConfigPath = getOmpUserConfigPath();
-  if (!existsSync28(userConfigPath)) {
+  if (!existsSync29(userConfigPath)) {
     add(results, "warn", `No Magic Context user config at ${userConfigPath}`);
     repairPlan.writeUserConfig = true;
   } else {
@@ -36511,7 +36871,7 @@ async function runHealthChecks(options) {
   const storage = getMagicContextStorageResolution();
   const dbPath = join24(storage.path, "context.db");
   add(results, "info", `Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync28(dbPath))
+  if (!existsSync29(dbPath))
     add(results, "info", `Shared context DB will be created at ${dbPath}`);
   else {
     let db = null;
@@ -36575,7 +36935,7 @@ function writeDefaultConfig(path) {
 }
 async function repair(plan, deps, prompts, cwd) {
   let fixed = 0;
-  if (plan.writeUserConfig && !existsSync28(getOmpUserConfigPath())) {
+  if (plan.writeUserConfig && !existsSync29(getOmpUserConfigPath())) {
     writeDefaultConfig(getOmpUserConfigPath());
     prompts.log.success(`Wrote default Magic Context config to ${getOmpUserConfigPath()}`);
     fixed += 1;
@@ -36732,7 +37092,7 @@ var init_doctor_omp = __esm(async () => {
     now: () => new Date,
     inspectMagicContextLogs,
     execFileSync: execFileSync5,
-    spawnSync: spawnSync5
+    spawnSync: spawnSync6
   };
 });
 
@@ -37632,12 +37992,12 @@ function listShadowBackfillStalls(db, projectIdentity) {
 var SHADOW_BACKFILL_PROVENANCE_KEY = "_magicContextShadowBackfill";
 
 // ../plugin/src/shared/auto-update-provenance.ts
-import { existsSync as existsSync29, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync30, readFileSync as readFileSync19 } from "node:fs";
 function readAutoUpdateCheckState(path) {
-  if (!existsSync29(path))
+  if (!existsSync30(path))
     return null;
   try {
-    const value = JSON.parse(readFileSync18(path, "utf-8"));
+    const value = JSON.parse(readFileSync19(path, "utf-8"));
     if (!value || typeof value !== "object" || Array.isArray(value))
       return null;
     const raw = value;
@@ -37665,9 +38025,9 @@ var init_auto_update_provenance = () => {};
 // ../plugin/src/shared/tui-config.ts
 import {
   chmodSync as chmodSync5,
-  existsSync as existsSync30,
+  existsSync as existsSync31,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   renameSync as renameSync6,
   statSync as statSync13,
   writeFileSync as writeFileSync6
@@ -37715,9 +38075,9 @@ function resolveTuiConfigPath(configDirOverride) {
   const configDir = configDirOverride ?? getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   const jsoncPath = join25(configDir, "tui.jsonc");
   const jsonPath = join25(configDir, "tui.json");
-  if (existsSync30(jsoncPath))
+  if (existsSync31(jsoncPath))
     return jsoncPath;
-  if (existsSync30(jsonPath))
+  if (existsSync31(jsonPath))
     return jsonPath;
   return jsoncPath;
 }
@@ -37725,8 +38085,8 @@ function ensureTuiPluginEntry(options = {}) {
   try {
     const configPath = resolveTuiConfigPath(options.configDir);
     let config = {};
-    if (existsSync30(configPath)) {
-      const raw = readFileSync19(configPath, "utf-8");
+    if (existsSync31(configPath)) {
+      const raw = readFileSync20(configPath, "utf-8");
       config = import_comment_json8.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config.plugin) ? [...config.plugin] : [];
@@ -37778,7 +38138,7 @@ var init_tui_config = __esm(() => {
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync31, readdirSync as readdirSync4, readFileSync as readFileSync20, statSync as statSync14 } from "node:fs";
+import { existsSync as existsSync32, readdirSync as readdirSync5, readFileSync as readFileSync21, statSync as statSync14 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import { join as join26 } from "node:path";
 function getSelfVersion() {
@@ -37793,29 +38153,52 @@ function getSelfVersion() {
   }
   return "unknown";
 }
-function getPluginCacheInfo() {
-  const [path = ""] = getOpenCodePluginCacheRoots();
+function readLegacyCachedVersion(root) {
+  try {
+    const pkg = JSON.parse(readFileSync21(getOpenCodePluginPackageJsonPath(root), "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : undefined;
+  } catch {
+    return;
+  }
+}
+function collectOpenCodePluginCacheReport(hostGeneration, opencodeConfig) {
+  const installs = [];
+  for (const root of getOpenCodePluginCacheRoots()) {
+    if (!existsSync32(root))
+      continue;
+    const spec = root.endsWith("@latest") ? "latest" : "(bare)";
+    installs.push({
+      layout: "opencode1",
+      spec,
+      path: root,
+      cached: readLegacyCachedVersion(root)
+    });
+  }
+  for (const slot of listOpenCodeV2PluginCacheSlots()) {
+    installs.push({
+      layout: "opencode2",
+      spec: slot.spec,
+      path: slot.slot,
+      cached: slot.version
+    });
+  }
+  let path;
   let cached;
-  for (const installedPkgPath of getOpenCodePluginPackageJsonPaths()) {
-    try {
-      if (existsSync31(installedPkgPath)) {
-        const pkg = JSON.parse(readFileSync20(installedPkgPath, "utf-8"));
-        cached = typeof pkg.version === "string" ? pkg.version : undefined;
-        if (cached)
-          break;
-      }
-    } catch {
-      cached = undefined;
-    }
+  if (hostGeneration === "v2") {
+    path = getOpenCodeV2PluginCacheSlot(undefined, readConfiguredOpenCodePluginSpec(opencodeConfig));
+    cached = readOpenCodeV2CachedPluginVersion(path);
+  } else {
+    [path = ""] = getOpenCodePluginCacheRoots();
+    cached = installs.find((install) => install.layout === "opencode1" && install.cached)?.cached;
   }
-  return { path, cached, latest: getSelfVersion() };
+  return { path, cached, latest: getSelfVersion(), installs };
 }
 function getStorageResolution() {
   return getMagicContextStorageResolution();
 }
 function fileSize(path) {
   try {
-    return existsSync31(path) ? statSync14(path).size : 0;
+    return existsSync32(path) ? statSync14(path).size : 0;
   } catch {
     return 0;
   }
@@ -37827,10 +38210,10 @@ function sanitizeValue(value) {
   return sanitizeConfigValue(value);
 }
 function readConfig3(path) {
-  if (!existsSync31(path))
+  if (!existsSync32(path))
     return { value: null };
   try {
-    const raw = readFileSync20(path, "utf-8");
+    const raw = readFileSync21(path, "utf-8");
     const value = import_comment_json9.parse(raw);
     return { value };
   } catch (error) {
@@ -37838,9 +38221,9 @@ function readConfig3(path) {
   }
 }
 function configHasPluginEntry(config) {
-  const plugins = readPluginEntries(config).map(({ entry }) => entry);
+  const plugins = readPluginEntries(config).map(({ entry }) => pluginEntryPackage(entry));
   return plugins.some((entry) => {
-    if (typeof entry !== "string")
+    if (entry === null)
       return false;
     if (entry === OPENCODE_PLUGIN_NAME)
       return true;
@@ -37855,7 +38238,7 @@ function configHasPluginEntry(config) {
 }
 function parseHistorianDumpMeta(path) {
   try {
-    const xml = readFileSync20(path, "utf-8");
+    const xml = readFileSync21(path, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -37888,10 +38271,10 @@ function parseHistorianDumpMeta(path) {
   }
 }
 function listDumpsInDir(dir, limit) {
-  if (!existsSync31(dir))
+  if (!existsSync32(dir))
     return { count: 0, recent: [] };
   try {
-    const entries = readdirSync4(dir).filter((name) => name.endsWith(".xml")).map((name) => {
+    const entries = readdirSync5(dir).filter((name) => name.endsWith(".xml")).map((name) => {
       const stat = statSync14(join26(dir, name));
       return {
         name,
@@ -38040,7 +38423,7 @@ async function collectRecentSessions(resolution, hostGeneration) {
 }
 async function collectHistorianFailures(storageDirPath) {
   const contextDbPath = join26(storageDirPath, "context.db");
-  if (!existsSync31(contextDbPath))
+  if (!existsSync32(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -38074,7 +38457,7 @@ async function collectHistorianFailures(storageDirPath) {
 }
 async function collectHistorianRuns(storageDirPath) {
   const contextDbPath = join26(storageDirPath, "context.db");
-  if (!existsSync31(contextDbPath))
+  if (!existsSync32(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined")
     return [];
@@ -38176,15 +38559,15 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync31(configPaths.magicContextConfig),
+      exists: existsSync32(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
-    pluginCache: getPluginCacheInfo(),
+    pluginCache: collectOpenCodePluginCacheReport(hostGeneration, opencodeConfig.value),
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync31(storageDirPath),
+      exists: existsSync32(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     openCodeDatabase: {
@@ -38231,7 +38614,12 @@ function renderDiagnosticsMarkdown(report) {
   const pluginCache = {
     path: sanitizeString(report.pluginCache.path),
     cached: report.pluginCache.cached ?? null,
-    latest: report.pluginCache.latest ?? null
+    latest: report.pluginCache.latest ?? null,
+    installs: (report.pluginCache.installs ?? []).map((install) => ({
+      ...install,
+      path: sanitizeString(install.path),
+      cached: install.cached ?? null
+    }))
   };
   const storage = {
     path: sanitizeString(report.storageDir.path),
@@ -38347,6 +38735,7 @@ var init_diagnostics_opencode = __esm(() => {
   init_conflict_detector();
   init_data_path();
   init_opencode_db_path();
+  init_opencode();
   init_log_lines();
   init_opencode_detect();
   init_opencode_helpers();
@@ -38410,8 +38799,8 @@ var init_embedding_local = __esm(() => {
 });
 
 // src/lib/embedding-runtime.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync32, readFileSync as readFileSync21 } from "node:fs";
+import { spawnSync as spawnSync7 } from "node:child_process";
+import { existsSync as existsSync33, readFileSync as readFileSync22 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { dirname as dirname16, join as join27, sep } from "node:path";
 function describeError(error) {
@@ -38420,7 +38809,7 @@ function describeError(error) {
   return typeof code === "string" && code.length > 0 ? `${code}: ${message}` : message;
 }
 function runOnnxRuntimeNodeLoadProbeChild(packageDir) {
-  return spawnSync6(process.execPath, ["-e", ONNX_RUNTIME_NODE_LOAD_PROBE_SCRIPT], {
+  return spawnSync7(process.execPath, ["-e", ONNX_RUNTIME_NODE_LOAD_PROBE_SCRIPT], {
     encoding: "utf8",
     env: { ...process.env, [ONNX_LOAD_PROBE_PACKAGE_DIR_ENV]: packageDir },
     stdio: ["ignore", "pipe", "pipe"],
@@ -38558,7 +38947,7 @@ function expectedBinaryRelPath(platform, arch) {
 }
 function onnxRuntimeNodeVersion(packageDir) {
   try {
-    const parsed = JSON.parse(readFileSync21(join27(packageDir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync22(join27(packageDir, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : undefined;
   } catch {
     return;
@@ -38607,7 +38996,7 @@ function formatLocalEmbeddingRuntimeWasmSelected(status) {
 function requireNodeWasmBundle(probe, candidates) {
   if (probe.state === "failed")
     return probe;
-  const bundlePath = candidates.find((candidate) => existsSync32(candidate));
+  const bundlePath = candidates.find((candidate) => existsSync33(candidate));
   return bundlePath ? probe : {
     state: "failed",
     reason: `functional Node WASM Transformers bundle is missing (checked ${candidates.join(", ")})`
@@ -38632,7 +39021,7 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
   }
   const packageDir = join27(installRoot, "node_modules", "onnxruntime-node");
   let native;
-  if (!existsSync32(join27(packageDir, "package.json"))) {
+  if (!existsSync33(join27(packageDir, "package.json"))) {
     native = { state: "package-missing", packageDir };
   } else {
     const rel = expectedBinaryRelPath(platform, arch);
@@ -38643,7 +39032,7 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
       };
     } else {
       const binaryPath = join27(packageDir, rel);
-      native = existsSync32(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
+      native = existsSync33(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
         state: "binary-missing",
         packageDir,
         expectedBinary: binaryPath,
@@ -38654,7 +39043,7 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
   return withWasmFallback(native, () => probeWasmRuntimeAt(installRoot));
 }
 function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  const existing = installRoots.filter((root) => existsSync32(root));
+  const existing = installRoots.filter((root) => existsSync33(root));
   if (existing.length === 0) {
     return {
       state: "unknown",
@@ -38701,7 +39090,7 @@ function probeWasmRuntimeByResolution(pluginDir) {
   }
 }
 function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  if (!existsSync32(join27(pluginDir, "package.json"))) {
+  if (!existsSync33(join27(pluginDir, "package.json"))) {
     return { state: "unknown", reason: "plugin package dir not found" };
   }
   const selectedRuntime = resolveLocalEmbeddingRuntime(runtimePreference, host);
@@ -38743,7 +39132,7 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
     native = probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath: onnxDir };
   } else {
     const binaryPath = join27(onnxDir, rel);
-    native = existsSync32(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
+    native = existsSync33(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
       state: "binary-missing",
       packageDir: onnxDir,
       expectedBinary: binaryPath,
@@ -39282,6 +39671,7 @@ var init_constants2 = __esm(() => {
   USER_OPENCODE_CONFIG = join29(getOpenCodeConfigRoot(), "opencode.json");
   USER_OPENCODE_CONFIG_JSONC = join29(getOpenCodeConfigRoot(), "opencode.jsonc");
 });
+
 // ../plugin/src/hooks/auto-update-checker/types.ts
 var NpmPackageEnvelopeSchema, OpencodePluginTupleSchema, OpencodeConfigSchema, PackageJsonSchema;
 var init_types = __esm(() => {
@@ -39303,14 +39693,14 @@ var init_types = __esm(() => {
 // ../plugin/src/hooks/auto-update-checker/checker.ts
 import {
   accessSync as accessSync2,
-  existsSync as existsSync33,
+  existsSync as existsSync34,
   constants as fsConstants,
-  readFileSync as readFileSync22,
+  readFileSync as readFileSync23,
   renameSync as renameSync7,
   statSync as statSync15,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname17, isAbsolute as isAbsolute7, join as join30, resolve as resolve8 } from "node:path";
+import { dirname as dirname17, isAbsolute as isAbsolute7, join as join30, resolve as resolve9 } from "node:path";
 function warn(message) {
   log3(`WARN: ${message}`);
 }
@@ -39357,9 +39747,9 @@ function getWinningConfig(directory, surface) {
   let winner = null;
   for (const path of getSurfaceConfigPaths(directory, surface)) {
     try {
-      if (!existsSync33(path))
+      if (!existsSync34(path))
         continue;
-      const parsed = parseJsonConfig(readFileSync22(path, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync23(path, "utf-8"));
       const entries = getPluginEntries(parsed);
       if (entries.some((entry) => entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))) {
         if (winner) {
@@ -39395,14 +39785,14 @@ var init_checker = __esm(() => {
 });
 
 // src/lib/opencode-plugin-schema-fence.ts
-import { existsSync as existsSync34, readdirSync as readdirSync5, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync35, readdirSync as readdirSync6, readFileSync as readFileSync24 } from "node:fs";
 import { join as join31 } from "node:path";
 import { gunzipSync } from "node:zlib";
 function readPackageVersion(packageJsonPath) {
   try {
-    if (!existsSync34(packageJsonPath))
+    if (!existsSync35(packageJsonPath))
       return null;
-    const packageJson = JSON.parse(readFileSync23(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync24(packageJsonPath, "utf-8"));
     if (packageJson.name !== OPENCODE_PLUGIN_NAME || typeof packageJson.version !== "string") {
       return null;
     }
@@ -39422,7 +39812,7 @@ function readFenceValue(text) {
 }
 function readFenceFromDist(packageDirectory) {
   const distDirectory = join31(packageDirectory, "dist");
-  if (!existsSync34(distDirectory))
+  if (!existsSync35(distDirectory))
     return null;
   const pending = [distDirectory];
   const fenceValues = new Set;
@@ -39431,7 +39821,7 @@ function readFenceFromDist(packageDirectory) {
     if (!directory)
       continue;
     try {
-      for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+      for (const entry of readdirSync6(directory, { withFileTypes: true })) {
         const path = join31(directory, entry.name);
         if (entry.isDirectory()) {
           pending.push(path);
@@ -39439,7 +39829,7 @@ function readFenceFromDist(packageDirectory) {
         }
         if (!entry.isFile() || !/\.(?:[cm]?js|ts)$/.test(entry.name))
           continue;
-        const fence = readFenceValue(readFileSync23(path, "utf-8"));
+        const fence = readFenceValue(readFileSync24(path, "utf-8"));
         if (fence !== null)
           fenceValues.add(fence);
       }
@@ -39453,7 +39843,7 @@ function findInstalledPluginPackage(cacheDirectory, specifier, requestedVersion)
   const directCacheRoot = join31(cacheDirectory, specifier);
   const candidates = [directCacheRoot];
   try {
-    for (const entry of readdirSync5(cacheDirectory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(cacheDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
       const candidate = join31(cacheDirectory, entry.name);
@@ -39837,22 +40227,22 @@ var init_doctor_harness_relabel = __esm(async () => {
 });
 
 // src/commands/doctor-opencode-cache.ts
-import { existsSync as existsSync35, readFileSync as readFileSync24, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync36, readFileSync as readFileSync25, rmSync as rmSync4 } from "node:fs";
 function readCachedPluginVersion(pluginCacheDir) {
   try {
     const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
-    if (!existsSync35(installedPkgPath))
+    if (!existsSync36(installedPkgPath))
       return;
-    const pkg = JSON.parse(readFileSync24(installedPkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync25(installedPkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
   }
 }
 async function clearPluginCache(options = {}, deps = {}) {
-  const remove = deps.remove ?? ((path) => rmSync3(path, { recursive: true, force: true }));
+  const remove = deps.remove ?? ((path) => rmSync4(path, { recursive: true, force: true }));
   const pluginCacheRoots = getOpenCodePluginCacheRoots();
-  const existingRoots = pluginCacheRoots.filter((root) => existsSync35(root));
+  const existingRoots = pluginCacheRoots.filter((root) => existsSync36(root));
   if (existingRoots.length === 0) {
     return { action: "not_found", path: pluginCacheRoots[0] ?? "" };
   }
@@ -39918,6 +40308,177 @@ var init_doctor_opencode_cache = __esm(() => {
   init_opencode_plugin_cache();
 });
 
+// src/commands/doctor-opencode-plugin-duplicates.ts
+import { isDeepStrictEqual } from "node:util";
+function entryOptions(entry) {
+  if (Array.isArray(entry))
+    return entry[1];
+  if (entry !== null && typeof entry === "object") {
+    return entry.options;
+  }
+  return;
+}
+function hasOptions(options) {
+  if (options === undefined || options === null)
+    return false;
+  if (typeof options === "object" && !Array.isArray(options)) {
+    return Object.keys(options).length > 0;
+  }
+  return true;
+}
+function followsLatest(specifier) {
+  return specifier === OPENCODE_PLUGIN_NAME || specifier === OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
+}
+function listMagicContextPluginEntries(config) {
+  const out = [];
+  for (const { key, index, entry } of readPluginEntries(config)) {
+    const specifier = pluginEntryPackage(entry);
+    if (specifier === null)
+      continue;
+    let kind = null;
+    if (matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME))
+      kind = "npm";
+    else if (isDevPathPluginEntry(entry))
+      kind = "dev-path";
+    if (kind === null)
+      continue;
+    out.push({ key, index, entry, specifier, kind, options: entryOptions(entry) });
+  }
+  return out;
+}
+function planPluginDuplicates(config) {
+  const entries = listMagicContextPluginEntries(config);
+  if (entries.length <= 1)
+    return { action: "none", entries };
+  if (entries.some((entry) => entry.kind === "dev-path")) {
+    return { action: "leave", reason: "dev-path", entries };
+  }
+  const optionSets = [];
+  for (const entry of entries) {
+    if (!hasOptions(entry.options))
+      continue;
+    if (!optionSets.some((seen) => isDeepStrictEqual(seen, entry.options))) {
+      optionSets.push(entry.options);
+    }
+  }
+  if (optionSets.length > 1) {
+    return { action: "leave", reason: "conflicting-options", entries };
+  }
+  const rank = (entry) => (followsLatest(entry.specifier) ? 2 : 0) + (hasOptions(entry.options) ? 1 : 0);
+  let keep = entries[0];
+  for (const entry of entries) {
+    if (rank(entry) > rank(keep))
+      keep = entry;
+  }
+  const remove = entries.filter((entry) => entry !== keep);
+  let replacement;
+  const carried = optionSets[0];
+  if (!hasOptions(keep.options) && carried !== undefined) {
+    const donor = entries.find((entry) => isDeepStrictEqual(entry.options, carried));
+    if (Array.isArray(donor?.entry)) {
+      const tuple = [...donor.entry];
+      tuple[0] = keep.specifier;
+      replacement = tuple;
+    } else {
+      replacement = { ...donor?.entry, package: keep.specifier };
+    }
+  }
+  return { action: "dedupe", entries, keep, remove, replacement };
+}
+function applyPluginDuplicatePlan(config, plan) {
+  if (plan.replacement !== undefined) {
+    const list = config[plan.keep.key];
+    list[plan.keep.index] = plan.replacement;
+  }
+  const removals = [...plan.remove].sort((a, b) => a.key === b.key ? b.index - a.index : a.key.localeCompare(b.key));
+  for (const entry of removals) {
+    config[entry.key].splice(entry.index, 1);
+  }
+}
+function describePluginEntry(entry) {
+  const suffix = hasOptions(entry.options) ? " (with options)" : "";
+  const kind = entry.kind === "dev-path" ? "dev path " : "";
+  return `${entry.key}[${entry.index}]: ${kind}${entry.specifier}${suffix}`;
+}
+function checkPluginDuplicates(config, configName, options, report) {
+  const plan = planPluginDuplicates(config);
+  if (plan.action === "none")
+    return false;
+  report.warn(`Magic Context is registered ${plan.entries.length} times in ${configName}; OpenCode loads the first and fails the rest as duplicates`);
+  for (const entry of plan.entries)
+    report.info(`  ${describePluginEntry(entry)}`);
+  if (plan.action === "leave") {
+    report.warn(plan.reason === "dev-path" ? "A local development checkout is registered next to another Magic Context entry; leaving every entry in place — remove the one you do not want by hand" : "Two Magic Context entries carry different options; leaving every entry in place — merge the options into one entry by hand");
+    return false;
+  }
+  if (!options.fix) {
+    report.info(`  Run 'doctor --fix' to keep ${plan.keep.key}[${plan.keep.index}] (${plan.keep.specifier}) and remove the others`);
+    return false;
+  }
+  applyPluginDuplicatePlan(config, plan);
+  report.pass(`Removed ${plan.remove.length} duplicate Magic Context ${plan.remove.length === 1 ? "entry" : "entries"} from ${configName}; kept ${plan.keep.specifier} under "${plan.keep.key}"${plan.replacement !== undefined ? " with the removed entry's options" : ""}`);
+  return true;
+}
+var init_doctor_opencode_plugin_duplicates = __esm(() => {
+  init_opencode();
+  init_opencode_plugin_cache();
+  init_opencode_plugin_registration();
+});
+
+// src/commands/doctor-opencode-plugin-entry.ts
+function isPinnedOpenCodePluginSpecifier(specifier) {
+  if (specifier === OPENCODE_PLUGIN_NAME || specifier === OPENCODE_PLUGIN_ENTRY_WITH_VERSION) {
+    return false;
+  }
+  return specifier.startsWith(`${OPENCODE_PLUGIN_NAME}@`);
+}
+function withPluginEntrySpecifier(entry, specifier) {
+  if (Array.isArray(entry) && entry.length >= 1) {
+    const replacement = [...entry];
+    replacement[0] = specifier;
+    return replacement;
+  }
+  if (entry !== null && typeof entry === "object" && !Array.isArray(entry)) {
+    return { ...entry, package: specifier };
+  }
+  return specifier;
+}
+function checkOpenCodePluginEntry(config, configName, options, report) {
+  const allEntries = readPluginEntries(config);
+  const found = allEntries.find(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry));
+  if (!found) {
+    const key = options.registrationKey;
+    const list = Array.isArray(config[key]) ? config[key] : [];
+    list.push(OPENCODE_PLUGIN_ENTRY_WITH_VERSION);
+    config[key] = list;
+    report.fixed(`Added plugin to ${configName}`);
+    return true;
+  }
+  const list = config[found.key];
+  const specifier = pluginEntryPackage(found.entry) ?? "";
+  if (specifier === OPENCODE_PLUGIN_ENTRY_WITH_VERSION) {
+    report.pass(`Plugin registered in ${configName}`);
+    return false;
+  }
+  if (isDevPathPluginEntry(found.entry)) {
+    report.pass(`Plugin registered in ${configName} (dev path: ${specifier})`);
+    return false;
+  }
+  if (isPinnedOpenCodePluginSpecifier(specifier) && !options.force) {
+    report.autoUpdateStall(specifier);
+    report.warn(`Plugin pinned to ${specifier} in ${configName} — use 'doctor --force' to upgrade`);
+    return false;
+  }
+  list[found.index] = withPluginEntrySpecifier(found.entry, OPENCODE_PLUGIN_ENTRY_WITH_VERSION);
+  report.fixed(`Upgraded plugin entry in ${configName}: ${specifier} → ${OPENCODE_PLUGIN_ENTRY_WITH_VERSION}`);
+  return true;
+}
+var init_doctor_opencode_plugin_entry = __esm(() => {
+  init_opencode();
+  init_opencode_plugin_cache();
+  init_opencode_plugin_registration();
+});
+
 // src/commands/doctor-store-generation.ts
 function hasColumn(db, table, column) {
   try {
@@ -39973,8 +40534,8 @@ function formatUnresolvedCompartmentSession(session) {
 }
 
 // src/commands/doctor-opencode.ts
-import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync36, mkdtempSync, readFileSync as readFileSync25, rmSync as rmSync4 } from "node:fs";
+import { spawnSync as spawnSync8 } from "node:child_process";
+import { existsSync as existsSync37, mkdtempSync, readFileSync as readFileSync26, rmSync as rmSync5 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
 import { homedir as homedir16, tmpdir as tmpdir3 } from "node:os";
 import { join as join32 } from "node:path";
@@ -39985,7 +40546,7 @@ function findUndeclaredConfiguredVariants(configured, catalog) {
     return model !== undefined && !Object.hasOwn(model.variants, entry.variant);
   });
 }
-function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args, cwd) => spawnSync7("opencode", args, {
+function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args, cwd) => spawnSync8("opencode", args, {
   cwd,
   encoding: "utf8",
   timeout: hostGeneration === "v2" ? 90000 : 45000,
@@ -40031,7 +40592,7 @@ function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args
       warn(`${entry.agent} model ${entry.model} requests variant '${entry.variant}', which this host does not offer. Remove the variant or choose one listed by ${guidance}.`);
     }
   } finally {
-    rmSync4(tempRoot, { recursive: true, force: true });
+    rmSync5(tempRoot, { recursive: true, force: true });
   }
 }
 function parseOpenCodeV2ModelCatalog(output) {
@@ -40150,12 +40711,12 @@ function checkUserMemoriesDreamerCompatibility(mcConfig) {
     return null;
   return 'dreamer.tasks["review-user-memories"] is scheduled but dreamer.disable=true, so new promotions will not run. Remove dreamer.disable or set dreamer.tasks["review-user-memories"].schedule="" to disable the task.';
 }
-async function fetchNpmLatest(pkg, timeoutMs = 5000) {
+async function fetchNpmLatest(pkg, distTag = "latest", timeoutMs = 5000) {
   try {
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const res = await fetch(`https://registry.npmjs.org/${pkg}/latest`, {
+      const res = await fetch(`${resolveNpmRegistryUrl()}/${pkg}/${encodeURIComponent(distTag)}`, {
         signal: controller.signal,
         headers: { Accept: "application/json" }
       });
@@ -40170,6 +40731,10 @@ async function fetchNpmLatest(pkg, timeoutMs = 5000) {
     return null;
   }
 }
+function resolveNpmRegistryUrl(env = process.env) {
+  const configured = (env.npm_config_registry ?? env.NPM_CONFIG_REGISTRY)?.trim();
+  return (configured || "https://registry.npmjs.org").replace(/\/+$/, "");
+}
 function getSelfVersion2() {
   const req = createRequire6(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -40181,11 +40746,6 @@ function getSelfVersion2() {
   }
   return "0.0.0";
 }
-function isPinnedOpenCodePluginSpecifier(specifier) {
-  if (specifier === OPENCODE_PLUGIN_NAME || specifier === OPENCODE_PLUGIN_ENTRY_WITH_VERSION)
-    return false;
-  return specifier.startsWith(`${OPENCODE_PLUGIN_NAME}@`);
-}
 function describeAutoUpdateStall(specifier, autoUpdateEnabled, storageDir = getMagicContextStorageDir()) {
   if (!autoUpdateEnabled || !isPinnedOpenCodePluginSpecifier(specifier))
     return null;
@@ -40203,10 +40763,10 @@ function getUserNpmrcPath() {
 function collectNpmReleaseAgeWarnings() {
   const ageWarnings = [];
   const npmrcPath = getUserNpmrcPath();
-  if (!existsSync36(npmrcPath))
+  if (!existsSync37(npmrcPath))
     return ageWarnings;
   try {
-    const npmrc = readFileSync25(npmrcPath, "utf-8");
+    const npmrc = readFileSync26(npmrcPath, "utf-8");
     for (const line of npmrc.split(`
 `)) {
       const trimmed = line.trim();
@@ -40239,15 +40799,15 @@ function compareVersions(a, b) {
 function openBrowser(url) {
   try {
     if (process.platform === "darwin") {
-      const child = spawnSync7("open", [url], { stdio: "ignore" });
+      const child = spawnSync8("open", [url], { stdio: "ignore" });
       if (child.status === 0)
         return;
     } else if (process.platform === "linux") {
-      const child = spawnSync7("xdg-open", [url], { stdio: "ignore" });
+      const child = spawnSync8("xdg-open", [url], { stdio: "ignore" });
       if (child.status === 0)
         return;
     } else if (process.platform === "win32") {
-      const child = spawnSync7("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+      const child = spawnSync8("cmd", ["/c", "start", "", url], { stdio: "ignore" });
       if (child.status === 0)
         return;
     }
@@ -40340,7 +40900,7 @@ function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync36(magicContextConfigPath)) {
+  if (!existsSync37(magicContextConfigPath)) {
     return checkLocalEmbeddingRuntimeForDoctor();
   }
   let rawText;
@@ -40671,7 +41231,7 @@ async function runDoctor2(options = {}) {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
   let autoUpdateEnabled = true;
-  if (existsSync36(paths.magicContextConfig)) {
+  if (existsSync37(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
@@ -40707,7 +41267,7 @@ async function runDoctor2(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log2.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync36(paths.magicContextConfig)) {
+  if (existsSync37(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -40837,59 +41397,35 @@ async function runDoctor2(options = {}) {
   };
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      const raw = readFileSync25(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync26(paths.opencodeConfig, "utf-8");
       const config = import_comment_json11.parse(raw);
-      const registrationKey = pluginConfigKeyFor(hostGeneration);
+      const configName = paths.opencodeConfigFormat === "jsonc" ? "opencode.jsonc" : "opencode.json";
+      if (checkPluginDuplicates(config, configName, options, {
+        warn,
+        pass: (message) => {
+          pass(message);
+          fixed++;
+        },
+        info: (message) => log2.info(message)
+      })) {
+        writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
+`);
+      }
       const allEntries = readPluginEntries(config);
-      const found = allEntries.find(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry));
-      const targetKey = found?.key ?? registrationKey;
-      const rawPlugins = Array.isArray(config?.[targetKey]) ? config[targetKey] : [];
-      const existingIdx = found ? found.index : -1;
       if (allEntries.some(({ entry }) => isLocalPathPluginEntry(entry) && String(entry).includes("magic-context") && !isDevPathPluginEntry(entry))) {
         warn("An unverifiable local OpenCode plugin path was ignored because its package name is not Magic Context");
       }
-      const configName = paths.opencodeConfigFormat === "jsonc" ? "opencode.jsonc" : "opencode.json";
-      const entryAsString = (entry) => {
-        if (typeof entry === "string")
-          return entry;
-        if (Array.isArray(entry) && typeof entry[0] === "string")
-          return entry[0];
-        return null;
-      };
-      if (existingIdx >= 0 && entryAsString(rawPlugins[existingIdx]) === OPENCODE_PLUGIN_ENTRY_WITH_VERSION) {
-        pass(`Plugin registered in ${configName}`);
-      } else if (existingIdx >= 0) {
-        const oldEntry = rawPlugins[existingIdx];
-        const oldEntryStr = entryAsString(oldEntry) ?? "";
-        if (isDevPathPluginEntry(oldEntry)) {
-          pass(`Plugin registered in ${configName} (dev path: ${oldEntryStr})`);
-        } else {
-          const isPinned = isPinnedOpenCodePluginSpecifier(oldEntryStr);
-          if (isPinned && !options.force) {
-            reportAutoUpdateStall(oldEntryStr);
-            warn(`Plugin pinned to ${oldEntryStr} in ${configName} — use 'doctor --force' to upgrade`);
-          } else {
-            if (Array.isArray(oldEntry) && oldEntry.length >= 1) {
-              const replacement = [...oldEntry];
-              replacement[0] = OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
-              rawPlugins[existingIdx] = replacement;
-            } else {
-              rawPlugins[existingIdx] = OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
-            }
-            config[targetKey] = rawPlugins;
-            writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
-`);
-            pass(`Upgraded plugin entry in ${configName}: ${oldEntryStr} → ${OPENCODE_PLUGIN_ENTRY_WITH_VERSION}`);
-            fixed++;
-          }
-        }
-      } else {
-        rawPlugins.push(OPENCODE_PLUGIN_ENTRY_WITH_VERSION);
-        config[targetKey] = rawPlugins;
+      if (checkOpenCodePluginEntry(config, configName, { force: options.force, registrationKey: pluginConfigKeyFor(hostGeneration) }, {
+        pass,
+        warn,
+        fixed: (message) => {
+          pass(message);
+          fixed++;
+        },
+        autoUpdateStall: reportAutoUpdateStall
+      })) {
         writeFileAtomic(paths.opencodeConfig, `${import_comment_json11.stringify(config, null, 2)}
 `);
-        pass(`Added plugin to ${configName}`);
-        fixed++;
       }
     } catch {
       warn("Could not parse opencode config to verify plugin entry");
@@ -40930,25 +41466,18 @@ async function runDoctor2(options = {}) {
       pass("Added TUI sidebar plugin to tui.json");
       warn("Restart OpenCode to see the sidebar");
       fixed++;
-    } else if (existsSync36(paths.tuiConfig)) {
+    } else if (existsSync37(paths.tuiConfig)) {
       try {
-        const tuiRaw = readFileSync25(paths.tuiConfig, "utf-8");
+        const tuiRaw = readFileSync26(paths.tuiConfig, "utf-8");
         const tuiConfig = import_comment_json11.parse(tuiRaw);
         const tuiRawPlugins = Array.isArray(tuiConfig?.plugin) ? tuiConfig.plugin : [];
         const tuiIdx = tuiRawPlugins.findIndex((entry) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry));
         if (tuiRawPlugins.some((entry) => isLocalPathPluginEntry(entry) && String(entry).includes("magic-context") && !isDevPathPluginEntry(entry))) {
           warn("An unverifiable local TUI plugin path was ignored because its package name is not Magic Context");
         }
-        const tuiEntryAsString = (entry) => {
-          if (typeof entry === "string")
-            return entry;
-          if (Array.isArray(entry) && typeof entry[0] === "string")
-            return entry[0];
-          return "";
-        };
         if (tuiIdx >= 0) {
           const tuiEntry = tuiRawPlugins[tuiIdx];
-          const tuiEntryStr = tuiEntryAsString(tuiEntry);
+          const tuiEntryStr = pluginEntryPackage(tuiEntry) ?? "";
           if (isDevPathPluginEntry(tuiEntry)) {
             pass(`TUI sidebar plugin configured (dev path: ${tuiEntryStr})`);
           } else {
@@ -40957,13 +41486,7 @@ async function runDoctor2(options = {}) {
               reportAutoUpdateStall(tuiEntryStr);
               warn(`TUI plugin pinned to ${tuiEntryStr} — use 'doctor --force' to upgrade`);
             } else if (tuiPinned && options.force) {
-              if (Array.isArray(tuiEntry) && tuiEntry.length >= 1) {
-                const replacement = [...tuiEntry];
-                replacement[0] = OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
-                tuiRawPlugins[tuiIdx] = replacement;
-              } else {
-                tuiRawPlugins[tuiIdx] = OPENCODE_PLUGIN_ENTRY_WITH_VERSION;
-              }
+              tuiRawPlugins[tuiIdx] = withPluginEntrySpecifier(tuiEntry, OPENCODE_PLUGIN_ENTRY_WITH_VERSION);
               tuiConfig.plugin = tuiRawPlugins;
               writeFileAtomic(paths.tuiConfig, `${import_comment_json11.stringify(tuiConfig, null, 2)}
 `);
@@ -40983,7 +41506,7 @@ async function runDoctor2(options = {}) {
       fail("Could not create or verify the TUI sidebar config");
     }
   }
-  if (existsSync36(paths.magicContextConfig)) {
+  if (existsSync37(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -41007,7 +41530,7 @@ async function runDoctor2(options = {}) {
   const storage = getMagicContextStorageResolution();
   const dbPath = join32(storage.path, "context.db");
   log2.info(`Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync36(dbPath)) {
+  if (!existsSync37(dbPath)) {
     log2.info(`Shared context DB not yet created at ${dbPath} (will be created on first run)`);
   } else {
     log2.info(`Shared context DB exists at ${dbPath}`);
@@ -41121,9 +41644,26 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
       log2.info(`  Manually delete: ${cacheResult.path}`);
     }
     issues++;
-  } else {
+  } else if (hostGeneration !== "v2") {
     pass("Plugin cache clean (no cached version found)");
   }
+  let v2DistTag;
+  if (paths.opencodeConfigFormat !== "none") {
+    try {
+      v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync26(paths.opencodeConfig, "utf-8")));
+    } catch {}
+  }
+  const v2Cache = reportOpenCodeV2PluginCache(checkOpenCodeV2PluginCache({
+    fix: options.fix,
+    force: options.force,
+    latestVersion: v2DistTag ? await fetchNpmLatest(OPENCODE_PLUGIN_NAME, v2DistTag) : pluginNpmLatest,
+    distTag: v2DistTag,
+    hostFiles: openCodeHostDatabaseFiles([openCodeDbResolution.path])
+  }), { pass, warn, info: (message) => log2.info(message) }, { reportMissing: hostGeneration === "v2" });
+  if (v2Cache.fixed)
+    fixed++;
+  if (v2Cache.issue)
+    issues++;
   {
     const ageWarnings = collectNpmReleaseAgeWarnings();
     if (ageWarnings.length > 0) {
@@ -41218,6 +41758,9 @@ var init_doctor_opencode = __esm(async () => {
   init_prompts();
   init_redaction2();
   init_doctor_opencode_cache();
+  init_doctor_opencode_plugin_duplicates();
+  init_doctor_opencode_plugin_entry();
+  init_doctor_opencode2_cache();
   await __promiseAll([
     init_storage_db(),
     init_sqlite(),
@@ -41231,7 +41774,7 @@ var init_doctor_opencode = __esm(async () => {
 });
 
 // src/lib/diagnostics-pi.ts
-import { existsSync as existsSync37, readdirSync as readdirSync6, readFileSync as readFileSync26, statSync as statSync16 } from "node:fs";
+import { existsSync as existsSync38, readdirSync as readdirSync7, readFileSync as readFileSync27, statSync as statSync16 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
 import { join as join33 } from "node:path";
 function getSelfVersion3() {
@@ -41248,7 +41791,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path) {
   try {
-    return existsSync37(path) ? statSync16(path).size : 0;
+    return existsSync38(path) ? statSync16(path).size : 0;
   } catch {
     return 0;
   }
@@ -41260,11 +41803,11 @@ function sanitizeValue2(value) {
   return sanitizeConfigValue(value);
 }
 function readJsonc(path) {
-  if (!existsSync37(path))
+  if (!existsSync38(path))
     return { value: {} };
   try {
     return {
-      value: import_comment_json12.parse(readFileSync26(path, "utf-8"))
+      value: import_comment_json12.parse(readFileSync27(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -41280,7 +41823,7 @@ function readConfigDiagnostic(path) {
   const parsed = readJsonc(path);
   return {
     path,
-    exists: existsSync37(path),
+    exists: existsSync38(path),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -41298,10 +41841,10 @@ function reverseSlugToDirectory(slug) {
 }
 function collectPiRecentSessions() {
   const sessionsRoot = getPiSessionsRoot();
-  if (!existsSync37(sessionsRoot))
+  if (!existsSync38(sessionsRoot))
     return [];
   try {
-    const slugs = readdirSync6(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    const slugs = readdirSync7(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     const candidates = [];
     for (const slug of slugs) {
       const directory = reverseSlugToDirectory(slug);
@@ -41310,7 +41853,7 @@ function collectPiRecentSessions() {
       const slugDir = join33(sessionsRoot, slug);
       let files;
       try {
-        files = readdirSync6(slugDir).filter((name) => name.endsWith(".jsonl"));
+        files = readdirSync7(slugDir).filter((name) => name.endsWith(".jsonl"));
       } catch {
         continue;
       }
@@ -41334,7 +41877,7 @@ function collectPiRecentSessions() {
 }
 function parseHistorianDumpMeta2(path) {
   try {
-    const xml = readFileSync26(path, "utf-8");
+    const xml = readFileSync27(path, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -41367,10 +41910,10 @@ function parseHistorianDumpMeta2(path) {
   }
 }
 function listDumpsInDir2(dir, limit) {
-  if (!existsSync37(dir))
+  if (!existsSync38(dir))
     return { count: 0, recent: [] };
   try {
-    const entries = readdirSync6(dir).filter((name) => name.endsWith(".xml")).map((name) => {
+    const entries = readdirSync7(dir).filter((name) => name.endsWith(".xml")).map((name) => {
       const stat = statSync16(join33(dir, name));
       return {
         name,
@@ -41461,7 +42004,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync37(settingsPath),
+      exists: existsSync38(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasPiMagicContextPackage(packages),
       packages: sanitizeValue2(packages)
@@ -41478,7 +42021,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync37(storageDirPath),
+      exists: existsSync38(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -41671,8 +42214,8 @@ var init_logs_pi = __esm(() => {
 });
 
 // src/commands/doctor-pi.ts
-import { execFileSync as execFileSync6, spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync38, mkdirSync as mkdirSync11, readdirSync as readdirSync7, readFileSync as readFileSync27, rmSync as rmSync5, statSync as statSync17 } from "node:fs";
+import { execFileSync as execFileSync6, spawnSync as spawnSync9 } from "node:child_process";
+import { existsSync as existsSync39, mkdirSync as mkdirSync11, readdirSync as readdirSync8, readFileSync as readFileSync28, rmSync as rmSync6, statSync as statSync17 } from "node:fs";
 import { createRequire as createRequire8 } from "node:module";
 import { homedir as homedir17 } from "node:os";
 import { dirname as dirname19, isAbsolute as isAbsolute8, join as join35 } from "node:path";
@@ -41766,7 +42309,7 @@ function summarize(results) {
 function readJsonc2(path) {
   try {
     return {
-      value: import_comment_json13.parse(readFileSync27(path, "utf-8"))
+      value: import_comment_json13.parse(readFileSync28(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -41818,13 +42361,13 @@ function piPluginDirCandidates(packages, cwd) {
   }
   dirs.push(join35(agentDir, "npm", "node_modules", PACKAGE_NAME2));
   dirs.push(join35(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
-  return dirs.filter((dir) => existsSync38(join35(dir, "package.json")));
+  return dirs.filter((dir) => existsSync39(join35(dir, "package.json")));
 }
 function projectConfigPath(cwd) {
   return resolveCortexKitProjectConfigPath(cwd);
 }
 function readConfigForEmbedding(path, isProjectConfig) {
-  if (!existsSync38(path))
+  if (!existsSync39(path))
     return null;
   try {
     const raw = loadRawConfigFile({
@@ -41925,7 +42468,7 @@ function cacheRoots(cwd) {
 function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
   const found = new Map;
   const visit = (path, depth) => {
-    if (depth < 0 || !existsSync38(path))
+    if (depth < 0 || !existsSync39(path))
       return;
     let stat;
     try {
@@ -41936,9 +42479,9 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     if (!stat.isDirectory())
       return;
     const packageJson = join35(path, "package.json");
-    if (existsSync38(packageJson)) {
+    if (existsSync39(packageJson)) {
       try {
-        const pkg = JSON.parse(readFileSync27(packageJson, "utf-8"));
+        const pkg = JSON.parse(readFileSync28(packageJson, "utf-8"));
         const name = typeof pkg.name === "string" ? pkg.name : "";
         const version = typeof pkg.version === "string" ? pkg.version : undefined;
         if (name === PACKAGE_NAME2) {
@@ -41953,7 +42496,7 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     }
     let entries = [];
     try {
-      entries = readdirSync7(path);
+      entries = readdirSync8(path);
     } catch {
       return;
     }
@@ -42003,7 +42546,7 @@ async function runHealthChecks2(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync38(settingsPath)) {
+  if (!existsSync39(settingsPath)) {
     add2(results, "fail", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -42027,7 +42570,7 @@ async function runHealthChecks2(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync38(path)) {
+    if (!existsSync39(path)) {
       if (required) {
         add2(results, "warn", `No ${label} magic-context.jsonc found at ${path}`);
         if (userConfigMigrationRefused) {
@@ -42069,7 +42612,7 @@ async function runHealthChecks2(options) {
   const storageDir = storage.path;
   const dbPath = join35(storageDir, "context.db");
   add2(results, "info", `Shared storage: ${storageDir} (source: ${storage.source})`);
-  const existedBeforeOpen = existsSync38(dbPath);
+  const existedBeforeOpen = existsSync39(dbPath);
   if (existedBeforeOpen)
     add2(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -42309,7 +42852,7 @@ function repair2(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync38(configPath)) {
+    if (!existsSync39(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -42321,7 +42864,7 @@ function repair2(plan, prompts) {
   }
   for (const path of plan.clearCachePaths) {
     try {
-      rmSync5(path, { recursive: true, force: true });
+      rmSync6(path, { recursive: true, force: true });
       prompts.log.success(`Cleared stale Pi extension cache: ${path}`);
       fixed += 1;
     } catch (error) {
@@ -42556,12 +43099,12 @@ var init_doctor_pi = __esm(async () => {
     openExistingContextDatabase,
     now: () => new Date,
     execFileSync: execFileSync6,
-    spawnSync: spawnSync8
+    spawnSync: spawnSync9
   };
 });
 
 // src/commands/doctor.ts
-import { existsSync as existsSync39, rmSync as rmSync6 } from "node:fs";
+import { existsSync as existsSync40, rmSync as rmSync7 } from "node:fs";
 import { join as join36 } from "node:path";
 async function runDoctor4(options) {
   if (options.clear)
@@ -42659,9 +43202,16 @@ async function runClear() {
   }
   const items = [];
   for (const adapter of installed) {
-    const cache = adapter.getPluginCacheInfo();
-    if (cache.path && cache.exists) {
-      items.push({ adapter, path: cache.path, sizeBytes: cache.sizeBytes });
+    for (const cache of adapter.getPluginCacheInfo()) {
+      if (cache.path && cache.exists) {
+        items.push({
+          adapter,
+          path: cache.path,
+          sizeBytes: cache.sizeBytes,
+          label: cache.label,
+          clear: cache.clear
+        });
+      }
     }
   }
   if (items.length === 0) {
@@ -42670,7 +43220,7 @@ async function runClear() {
     return 0;
   }
   const picks = await selectMany("Select caches to clear:", items.map((item, idx) => ({
-    label: `${item.adapter.displayName}: ${formatSize(item.sizeBytes)} — ${item.path}`,
+    label: `${item.adapter.displayName}${item.label ? ` (${item.label})` : ""}: ${formatSize(item.sizeBytes)} — ${item.path}`,
     value: String(idx)
   })));
   if (picks.length === 0) {
@@ -42693,8 +43243,16 @@ async function runClear() {
     const s = spinner2();
     s.start(`Clearing ${item.path}`);
     try {
-      if (existsSync39(item.path)) {
-        rmSync6(item.path, { recursive: true, force: true });
+      if (item.clear) {
+        const result = item.clear();
+        if (!result.cleared) {
+          s.stop(`Left in place: ${item.path}`);
+          log2.warn(result.reason);
+          failed += 1;
+          continue;
+        }
+      } else if (existsSync40(item.path)) {
+        rmSync7(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);
     } catch (err) {