@cortexkit/magic-context 0.43.1 → 0.44.0

package/dist/index.js

@@ -4203,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();
@@ -4603,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");
@@ -4646,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))
@@ -4733,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
   };
@@ -12652,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";
@@ -12670,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,
@@ -12686,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") {
@@ -12695,25 +13016,34 @@ 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 openChamberCliCandidates(d) {
+  if (d.platform !== "darwin")
+    return [];
+  const bundled = ["Contents", "Resources", "opencode-cli", "opencode"];
+  return [
+    join11("/Applications", "OpenChamber.app", ...bundled),
+    join11(d.home, "Applications", "OpenChamber.app", ...bundled)
   ];
 }
 function canonicalPath(d, path) {
@@ -12734,29 +13064,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`));
     }
   }
 }
@@ -12777,8 +13107,13 @@ function detectOpenCodeInstallations(deps) {
       addCandidate(installations, seenRealpaths, d, candidate, "PATH", "cli");
     }
   }
+  for (const candidate of openChamberCliCandidates(d)) {
+    if (d.isExecutable(candidate)) {
+      addCandidate(installations, seenRealpaths, d, candidate, "openchamber", "cli");
+    }
+  }
   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");
     }
@@ -12850,6 +13185,17 @@ function describeOpenCodeInstallations(installations, deps = {}) {
     active: index === 0
   }));
 }
+function selectOpenCodeStoreHost(reports, generationOf) {
+  const active = reports[0];
+  if (!active)
+    return null;
+  const hasVersion = (report) => /\d/.test(report.version);
+  if (!hasVersion(active) || generationOf(active.version) === "v2") {
+    return { host: active, shadowed: false };
+  }
+  const v2 = reports.find((report) => report.kind === "cli" && hasVersion(report) && generationOf(report.version) === "v2");
+  return v2 ? { host: v2, shadowed: true } : { host: active, shadowed: false };
+}
 function getAvailableModels2(binary) {
   const output = runOpenCode(["models"], binary);
   if (output === null)
@@ -12860,50 +13206,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 {
@@ -12911,21 +13216,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";
@@ -12935,7 +13239,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 {
@@ -12971,7 +13275,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 {
@@ -13046,7 +13350,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 {
@@ -13096,22 +13400,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;
@@ -13147,15 +13512,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);
@@ -13175,7 +13540,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 });
   }
@@ -13183,6 +13548,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();
@@ -13193,7 +13559,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;
@@ -13368,7 +13734,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;
   }
@@ -13376,10 +13742,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 };
@@ -13391,7 +13757,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(`
 `);
@@ -13407,9 +13773,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), {
@@ -13458,7 +13824,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;
@@ -13515,10 +13881,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;
@@ -13554,7 +13920,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 {
@@ -13656,7 +14022,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");
@@ -13693,7 +14059,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 });
   }
@@ -13823,10 +14189,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,
@@ -14026,7 +14392,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)) {
@@ -14070,11 +14436,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)}`);
   }
@@ -14118,7 +14484,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 {
@@ -14490,10 +14856,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() {
@@ -15182,6 +15548,12 @@ var init_redaction = __esm(() => {
 // ../plugin/src/shared/logger.ts
 import * as fs from "node:fs";
 import * as path2 from "node:path";
+function boundBuffer() {
+  while (bufferedBytes > MAX_BUFFERED_BYTES && buffer.length > 0) {
+    bufferedBytes -= Buffer.byteLength(buffer.shift() ?? "");
+    droppedLines++;
+  }
+}
 function recordSwallowedWrite(error) {
   try {
     swallowedWriteCount++;
@@ -15264,12 +15636,12 @@ function flush() {
     clearTimeout(flushTimer);
     flushTimer = null;
   }
-  if (buffer.length === 0)
+  if (buffer.length === 0 && droppedLines === 0)
     return;
-  const bufferedData = buffer.join("");
-  buffer = [];
+  const notice = droppedLines ? `[${new Date().toISOString()}] [magic-context][global] logger dropped ${droppedLines} ${droppedLines === 1 ? "line" : "lines"}: buffer exceeded ${MAX_BUFFERED_BYTES} bytes while writes were pending
+` : "";
   try {
-    const data = capLogData(bufferedData);
+    const data = capLogData(notice + buffer.join(""));
     const logFile = getMagicContextLogPath();
     ensureDir4(logFile);
     let currentSize = getCurrentLogSize(logFile);
@@ -15279,6 +15651,9 @@ function flush() {
       currentSize = 0;
     }
     fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 384 });
+    buffer = [];
+    bufferedBytes = 0;
+    droppedLines = 0;
     activeLogFile = logFile;
     activeLogSize = currentSize + dataSize;
     flushesSinceSizeCheck++;
@@ -15287,6 +15662,7 @@ function flush() {
     activeLogSize = null;
     flushesSinceSizeCheck = 0;
     recordSwallowedWrite(error);
+    boundBuffer();
   }
 }
 function scheduleFlush() {
@@ -15304,8 +15680,11 @@ function log3(message, data) {
     const timestamp = new Date().toISOString();
     const serialized = data === undefined ? "" : data instanceof Error ? ` ${sanitizeDiagnosticText(`${data.message}${data.stack ? `
 ${data.stack}` : ""}`)}` : ` ${JSON.stringify(sanitizeConfigValue(data))}`;
-    buffer.push(`[${timestamp}] ${sanitizeDiagnosticText(message)}${serialized}
-`);
+    const line = `[${timestamp}] ${sanitizeDiagnosticText(message)}${serialized}
+`;
+    buffer.push(line);
+    bufferedBytes += Buffer.byteLength(line);
+    boundBuffer();
     if (buffer.length >= BUFFER_SIZE_LIMIT) {
       flush();
     } else {
@@ -15313,11 +15692,12 @@ ${data.stack}` : ""}`)}` : ` ${JSON.stringify(sanitizeConfigValue(data))}`;
     }
   } catch {}
 }
-var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, MAX_LOG_FILE_BYTES, SIZE_CHECK_INTERVAL_FLUSHES = 64, activeLogFile = null, activeLogSize = null, flushesSinceSizeCheck = 0, swallowedWriteCount = 0, lastErrorMessage = null, lastErrorTime = null;
+var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, MAX_BUFFERED_BYTES, bufferedBytes = 0, droppedLines = 0, MAX_LOG_FILE_BYTES, SIZE_CHECK_INTERVAL_FLUSHES = 64, activeLogFile = null, activeLogSize = null, flushesSinceSizeCheck = 0, swallowedWriteCount = 0, lastErrorMessage = null, lastErrorTime = null;
 var init_logger = __esm(() => {
   init_data_path();
   init_redaction();
   buffer = [];
+  MAX_BUFFERED_BYTES = 1024 * 1024;
   MAX_LOG_FILE_BYTES = 32 * 1024 * 1024;
   if (!isTestEnv) {
     process.on("exit", flush);
@@ -21029,6 +21409,7 @@ var init_magic_context = __esm(() => {
     maxTokens: true
   });
   DreamerConfigSchema = AgentMetadataSchema.extend({
+    runner: _enum(["broca", "host"]).optional().describe(`Which side runs the dreamer completions the Rust module routes (classify-memories) in Rust transform mode: "host" runs them on this process's carrier, "broca" routes them to the Broca module. When unset, historian.runner applies, and when that is unset too the harness decides the same way it does for the historian. User-level config only.`),
     opencode: DreamerOpenCodeHarnessBlockSchema.optional(),
     pi: DreamerPiHarnessBlockSchema.optional(),
     omp: DreamerOmpHarnessBlockSchema.optional(),
@@ -21039,12 +21420,16 @@ var init_magic_context = __esm(() => {
     opencode: OpenCodeHarnessBlockSchema.optional(),
     pi: PiHarnessBlockSchema.optional(),
     omp: OmpHarnessBlockSchema.optional(),
+    runner: _enum(["broca", "host"]).optional().describe('Which side runs the historian completion in Rust transform mode: "host" queues it for this process to run on the configured historian model, "broca" routes it to the Broca module. When unset the harness decides: OpenCode 1 and OpenCode 2 use "host", Claude Code (through the Thalamus gateway, which has no host to run a completion) uses "broca". User-level config only — it decides whose provider account pays for the call.'),
+    host_runner: object({
+      enabled: boolean2().optional().describe("Whether this process answers historian runs queued for a claimant (default true). Setting it to false stops the pull loop without changing historian.runner, so an operator can take one machine out of the lane and leave the queued runs for another claimant or for the runner setting to be changed deliberately.")
+    }).optional().describe("Controls for this process's historian pull loop, which answers runs the Rust module queues for the host runner (`historian.runner: \"host\"`, or unset on OpenCode 1 and OpenCode 2). User-level config only — it decides whether this machine's provider account is spent on folds."),
     two_pass: boolean2().default(false).describe("Run a second editor pass over historian output to clean low-signal U: lines and cross-compartment duplicates. Adds ~1 extra API call and ~1.3x cost per historian run. Useful for models without extended thinking support. (default: false)"),
     disallowed_tools: array(_enum(["*", "read", "aft_outline", "aft_zoom", "aft_search"])).default([]).describe(`OpenCode only. Tools to REMOVE from the historian's default allow-list [read, aft_outline, aft_zoom, aft_search]. Applies to both historian and historian-editor agents. Use ["*"] to strip all tool definitions from the model request — this prevents weak instruction-following models (e.g. mistral-small-latest) from entering tool-calling loops. Individual tool names remove just that tool. Note: a user-supplied historian.permission override can re-allow a tool that disallowed_tools removed — disallowed_tools sets the baseline, permission overrides take precedence. (default: [])`)
   }).optional();
   EmbeddingFallbackProviderSchema = _enum(["local", "openai-compatible", "off"]);
   BaseEmbeddingConfigSchema = object({
-    provider: _enum(["local", "openai-compatible", "off", "synapse"]).default("local").describe("Embedding provider. 'local' uses Xenova/all-MiniLM-L6-v2, 'openai-compatible' requires endpoint and model, 'synapse' uses the certified local Synapse lane with an explicit fallback provider, and 'off' disables embeddings."),
+    provider: _enum(["local", "openai-compatible", "off", "synapse"]).default("local").describe("Embedding provider. 'local' uses Xenova/all-MiniLM-L6-v2, 'openai-compatible' requires endpoint and model, 'synapse' uses the certified local Synapse lane with an explicit fallback provider, and 'off' disables embeddings. Session history is embedded for semantic ctx_search whenever the provider is not 'off', regardless of memory.enabled; memories are embedded only while memory.enabled is true."),
     fallback_provider: EmbeddingFallbackProviderSchema.optional().describe("Fallback provider for the Synapse lane. Required when provider is 'synapse'; local, openai-compatible, and off are valid."),
     model: string2().optional().describe("Embedding model name. Required for openai-compatible, ignored for local."),
     endpoint: string2().optional().describe("API endpoint URL. Required when provider is openai-compatible."),
@@ -21225,7 +21610,7 @@ var init_magic_context = __esm(() => {
       min_chars: number2().min(100).max(1e4).default(500).describe("Text parts shorter than this (characters) stay untouched. Min 100, max 10000. Default: 500.")
     }).default({ enabled: false, min_chars: 500 }).describe("Age-tier caveman compression for long user/assistant text parts. Active for primary sessions when enabled; never for subagents. Oldest 20% of eligible tags (outside protected tail) go to ultra, next 20% to full, next 20% to lite, newest 40% untouched. Graduated from experimental.caveman_text_compression; opt-in, default off (lossy)."),
     memory: object({
-      enabled: boolean2().default(true).describe("Enable cross-session memory (default: true)"),
+      enabled: boolean2().default(true).describe("Enable cross-session memory (default: true). Does not affect history embedding or semantic ctx_search over session history; set embedding.provider to 'off' to stop all embedding."),
       injection_budget_tokens: number2().min(500).max(20000).default(4000).describe("Token budget for memory injection on session start (min: 500, max: 20000, default: 4000)"),
       auto_promote: boolean2().default(true).describe("Automatically promote eligible session facts into memory (default: true)"),
       retrieval_count_promotion_threshold: number2().min(1).default(3).describe("retrieval_count threshold for promoting memory to permanent status (min: 1, default: 3)"),
@@ -21674,6 +22059,11 @@ function stripUnsafeProjectConfigFields(projectRaw) {
       warnings.push(`Ignoring ${removed.map((path) => `historian.${path}`).join(", ")} from project config ` + "(security: historian model selection is user-level only; a repository cannot force extra compaction cost).");
     }
   }
+  const dreamer = projectRaw.dreamer;
+  if (isPlainObject3(dreamer) && "runner" in dreamer) {
+    delete dreamer.runner;
+    warnings.push("Ignoring dreamer.runner from project config (security: which process and provider account run dreamer completions is a user-level setting).");
+  }
   const mural = projectRaw.mural;
   if (isPlainObject3(mural) && "model" in mural) {
     delete mural.model;
@@ -21855,7 +22245,11 @@ var init_project_security = __esm(() => {
   init_magic_context();
   HIDDEN_AGENT_KEYS = ["historian", "dreamer"];
   HARNESS_KEYS = PER_HARNESS_MODEL_KEYS;
-  HISTORIAN_USER_ONLY_FIELDS = PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution;
+  HISTORIAN_USER_ONLY_FIELDS = [
+    ...PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution,
+    "runner",
+    "host_runner"
+  ];
   PROMPT_SURFACE_USER_ONLY_FIELDS = ["guidance_override_path", "tool_descriptions"];
   AGENT_ESCALATION_FIELDS = ["prompt", "permission", "tools"];
   EMBEDDING_USER_ONLY_FIELDS = [
@@ -21919,16 +22313,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}/`)) {
@@ -21986,21 +22380,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`);
@@ -22019,7 +22413,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();
 }
@@ -22027,10 +22421,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;
@@ -22170,6 +22564,25 @@ function redactConfigValue(value) {
 function formatProtectedTokensBelowMinWarning(value) {
   return `protected_tokens is a token floor (minimum ${PROTECTED_TOKENS_MIN}, default derived from the context window); ${value} looks like the old protected_tags count. Remove the key to use the default, or set a token count such as 16000.`;
 }
+function misplacedAgentModelWarnings(rawConfig) {
+  const warnings = [];
+  for (const agent of ["historian", "dreamer"]) {
+    const block = rawConfig[agent];
+    if (!block || typeof block !== "object" || Array.isArray(block))
+      continue;
+    const record = block;
+    if (!Object.hasOwn(record, "model"))
+      continue;
+    const harnessWithModel = MODEL_HARNESS_BLOCKS.find((harness) => {
+      const sub = record[harness];
+      return sub !== null && typeof sub === "object" && !Array.isArray(sub) && Object.hasOwn(sub, "model");
+    });
+    if (harnessWithModel)
+      continue;
+    warnings.push(`${agent}.model is not read: the ${agent} model is resolved per harness, so it has to be ${agent}.opencode.model (OpenCode 1 and 2), ${agent}.pi.model, or ${agent}.omp.model. As written the ${agent} resolves to no models and never runs.`);
+  }
+  return warnings;
+}
 function warnProtectedTagsDeprecationOnce() {
   if (!warnedProtectedTagsDeprecation) {
     warnedProtectedTagsDeprecation = true;
@@ -22183,6 +22596,7 @@ function parsePluginConfig(rawConfig, recoveredTopLevelKeys = []) {
     warnProtectedTagsDeprecationOnce();
     preMigrationWarnings.push("protected_tags is deprecated and ignored; use protected_tokens instead.");
   }
+  preMigrationWarnings.push(...misplacedAgentModelWarnings(rawConfig));
   const migratedExperimental = migrateLegacyExperimental(configWithoutRemovedAgent, preMigrationWarnings);
   const migratedDreamer = migrateDreamerV2(migratedExperimental, preMigrationWarnings);
   const migrated = migrateLegacyAgentEnabledInMemory(migratedDreamer, preMigrationWarnings);
@@ -22343,8 +22757,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 = [];
@@ -22463,7 +22877,7 @@ function loadPluginConfigDetailed(directory, applyRuntimeGlobals = true) {
     cacheTtlConfigured
   };
 }
-var warnedProtectedTagsDeprecation = false;
+var warnedProtectedTagsDeprecation = false, MODEL_HARNESS_BLOCKS;
 var init_config = __esm(() => {
   init_config_diagnostics();
   init_jsonc_parser();
@@ -22478,11 +22892,12 @@ var init_config = __esm(() => {
   init_removed_agent_config();
   init_magic_context();
   init_variable();
+  MODEL_HARNESS_BLOCKS = ["opencode", "pi", "omp"];
 });
 
 // ../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();
 }
@@ -22494,7 +22909,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();
@@ -22781,7 +23196,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) {
@@ -22791,11 +23206,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 {
@@ -22807,14 +23222,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 [
@@ -22823,7 +23238,7 @@ function collectOpenCodeConfigPaths(directory) {
     join16(directory, "opencode.jsonc"),
     join16(directory, "opencode.json")
   ]) {
-    if (existsSync18(filePath)) {
+    if (existsSync19(filePath)) {
       paths.add(filePath);
     }
   }
@@ -22835,10 +23250,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);
     }
   }
@@ -22846,13 +23261,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);
     }
   }
@@ -22980,7 +23395,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 {
@@ -22992,7 +23407,7 @@ function resolveCompactionEnabledForWriter() {
   }
 }
 function ensureDir5(dir) {
-  if (!existsSync19(dir)) {
+  if (!existsSync20(dir)) {
     mkdirSync5(dir, { recursive: true });
   }
 }
@@ -23021,7 +23436,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));
@@ -23033,7 +23448,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;
@@ -23079,7 +23494,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));
@@ -23095,7 +23510,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) {
@@ -23201,7 +23616,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([
@@ -24491,7 +24906,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;
@@ -24729,7 +25144,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 {
@@ -26406,6 +26821,297 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// ../plugin/src/shared/user-facing-codes.ts
+function userFacingFailureCode(key) {
+  return USER_FACING_FAILURES[key].code;
+}
+var USER_FACING_FAILURES;
+var init_user_facing_codes = __esm(() => {
+  USER_FACING_FAILURES = {
+    historian_unavailable: {
+      code: "MC-H01",
+      sentence: "History compression could not finish this turn.",
+      action: "It will retry automatically."
+    },
+    hidden_cleanup_unbound: {
+      code: "MC-H02",
+      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.",
+      action: "Run /ctx-recomp again."
+    },
+    dream_provider_timeout: {
+      code: "MC-D01",
+      sentence: "Memory maintenance took too long to respond.",
+      action: "Run /ctx-dream again."
+    },
+    dream_provider_error: {
+      code: "MC-D02",
+      sentence: "Memory maintenance could not reach its model.",
+      action: "Check the model connection, then run /ctx-dream again."
+    },
+    dream_step_limit: {
+      code: "MC-D10",
+      sentence: "Memory maintenance stopped at its hidden agent step limit.",
+      action: "This task needs less work per run; changing the model connection will not help."
+    },
+    dream_empty_completion: {
+      code: "MC-D03",
+      sentence: "Memory maintenance received no usable response.",
+      action: "Run /ctx-dream again."
+    },
+    dream_no_models: {
+      code: "MC-D04",
+      sentence: "Memory maintenance has no model available.",
+      action: "Check the model settings, then run /ctx-dream again."
+    },
+    dream_child_aborted: {
+      code: "MC-D05",
+      sentence: "Memory maintenance was interrupted.",
+      action: "Run /ctx-dream again."
+    },
+    dream_parse_failed: {
+      code: "MC-D06",
+      sentence: "Memory maintenance could not use the model response.",
+      action: "Run /ctx-dream again."
+    },
+    dream_unknown: {
+      code: "MC-D07",
+      sentence: "Memory maintenance could not finish.",
+      action: "Run /ctx-dream again."
+    },
+    dreamer_tick_blocked: {
+      code: "MC-D09",
+      sentence: "Background maintenance is not running: its last pass stopped before it reached the scheduled tasks.",
+      action: "It is retried automatically; if it keeps happening, check the Magic Context log for the stage that stopped and run `npx @cortexkit/magic-context doctor`."
+    },
+    dream_task_needs_tool_loop: {
+      code: "MC-D08",
+      sentence: "Some memory maintenance tasks need a tool loop this host does not provide.",
+      action: "The remaining tasks still run; the listed ones are skipped on this host."
+    },
+    embedding_substitution_rejected: {
+      code: "MC-E01",
+      sentence: "Search indexing could not use the selected model.",
+      action: "Check the embedding model setting, then run /ctx-embed start again."
+    },
+    embedding_http_error: {
+      code: "MC-E02",
+      sentence: "The search indexing provider refused the request.",
+      action: "Check the provider connection and credentials, then run /ctx-embed start again."
+    },
+    embedding_transport_error: {
+      code: "MC-E03",
+      sentence: "Search indexing could not reach its provider.",
+      action: "Check the connection, then run /ctx-embed start again."
+    },
+    embedding_invalid_envelope: {
+      code: "MC-E04",
+      sentence: "Search indexing received an unsupported response.",
+      action: "Check the embedding endpoint, then run /ctx-embed start again."
+    },
+    embedding_empty_result: {
+      code: "MC-E05",
+      sentence: "Search indexing received no usable result.",
+      action: "Run /ctx-embed start again."
+    },
+    embedding_certification_refusal: {
+      code: "MC-E06",
+      sentence: "Search indexing is not ready for this provider.",
+      action: "Finish the provider setup, or set a fallback provider in the embedding settings, then run /ctx-embed start again."
+    },
+    embedding_credential_required: {
+      code: "MC-E07",
+      sentence: "Search indexing needs provider credentials.",
+      action: "Sign in to the provider, then run /ctx-embed start again."
+    },
+    embedding_local_binding_missing: {
+      code: "MC-E08",
+      sentence: "Local search indexing is unavailable on this system.",
+      action: "Run `npx @cortexkit/magic-context doctor`, then retry."
+    },
+    embedding_local_fs_unavailable: {
+      code: "MC-E09",
+      sentence: "Local search indexing cannot save its model files.",
+      action: "Update or reinstall Magic Context, then retry."
+    },
+    embedding_local_download_failure: {
+      code: "MC-E10",
+      sentence: "Local search indexing could not download its model.",
+      action: "Check the network connection, then retry."
+    },
+    embedding_local_runtime_error: {
+      code: "MC-E11",
+      sentence: "Local search indexing could not start.",
+      action: "Run `npx @cortexkit/magic-context doctor`, then retry."
+    },
+    embedding_unavailable: {
+      code: "MC-E12",
+      sentence: "Search indexing could not finish.",
+      action: "Run /ctx-embed start again."
+    },
+    status_unavailable: {
+      code: "MC-S01",
+      sentence: "Magic Context status is temporarily unavailable.",
+      action: "Retry /ctx-status in a moment."
+    },
+    transform_update_failed: {
+      code: "MC-S02",
+      sentence: "The last context update did not finish.",
+      action: "Send another message to retry."
+    },
+    configuration_warning: {
+      code: "MC-S03",
+      sentence: "Some configuration settings could not be applied.",
+      action: "Fix the configuration warning shown in /ctx-status, then restart."
+    },
+    status_log_unavailable: {
+      code: "MC-S04",
+      sentence: "Some diagnostic details could not be saved.",
+      action: "Retry /ctx-status in a moment."
+    },
+    memory_writes_paused: {
+      code: "MC-C01",
+      sentence: "Memory writes are paused while the engine syncs.",
+      action: "Retry in a moment."
+    },
+    memory_access_unavailable: {
+      code: "MC-C02",
+      sentence: "Memory access is temporarily unavailable.",
+      action: "Retry in a moment."
+    },
+    note_changes_paused: {
+      code: "MC-C03",
+      sentence: "Note changes are paused while the engine syncs.",
+      action: "Retry in a moment."
+    },
+    note_access_unavailable: {
+      code: "MC-C04",
+      sentence: "Notes are temporarily unavailable.",
+      action: "Retry in a moment."
+    },
+    context_cleanup_paused: {
+      code: "MC-C05",
+      sentence: "Context cleanup is paused while the engine syncs.",
+      action: "Retry in a moment."
+    },
+    partial_history_unavailable: {
+      code: "MC-C06",
+      sentence: "Partial history compression is not available in the current mode.",
+      action: "Run /ctx-recomp without a range."
+    },
+    smart_note_conditions_unavailable: {
+      code: "MC-C08",
+      sentence: "Conditional notes are not available in the current mode.",
+      action: "Save a regular note without a condition."
+    },
+    history_compression_paused: {
+      code: "MC-C09",
+      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.",
+      action: "Retry in a moment."
+    },
+    store_ahead_of_binary: {
+      code: "MC-C13",
+      sentence: "Magic Context refused to start: its store (store.db) was migrated by a newer ck-mc build than the one running.",
+      action: "Update ck-mc, or roll back by restoring ck-mc together with context.db and store.db from the same backup."
+    },
+    compaction_marker_missing: {
+      code: "MC-C11",
+      sentence: "The history boundary marker is missing from the OpenCode store, so requests carry the full session.",
+      action: "It is retried on every message; if this persists, run `/ctx-flush`."
+    },
+    memory_mirror_stalled: {
+      code: "MC-M01",
+      sentence: "Memory synchronization stopped before the host mirror caught up.",
+      action: "Send another message to resume it, or run `ck doctor drain-authority`."
+    },
+    memory_authority_mismatch: {
+      code: "MC-M02",
+      sentence: "Memory authority is inconsistent between the host and module.",
+      action: "Run `ck doctor drain-authority` before changing Rust mode."
+    },
+    dreamer_task_failing: {
+      code: "MC-S05",
+      sentence: "A background maintenance task keeps failing on its schedule.",
+      action: "Check the Magic Context log for the failing task and its error."
+    }
+  };
+});
+
+// ../plugin/src/hooks/magic-context/store-ahead-refusal.ts
+function renderStoreAheadOfBinaryRefusal(versions) {
+  const failure = USER_FACING_FAILURES.store_ahead_of_binary;
+  const sentence = versions ? `Magic Context refused to start: its store (store.db) is at schema v${versions.dbVersion} but this ck-mc build only knows up to v${versions.binaryMax}.` : failure.sentence;
+  return `${sentence} ${failure.action} (${failure.code})`;
+}
+function isRecord4(value) {
+  return value !== null && typeof value === "object";
+}
+function nonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function versionsFromDetail(detail) {
+  if (!isRecord4(detail))
+    return null;
+  const dbVersion = nonNegativeInteger(detail.db_version);
+  const binaryMax = nonNegativeInteger(detail.binary_max);
+  return dbVersion !== null && binaryMax !== null ? { dbVersion, binaryMax } : null;
+}
+function versionsFromMessage(message) {
+  if (typeof message !== "string")
+    return null;
+  const match = /db_version=(\d+) binary_max=(\d+)/.exec(message) ?? /schema v(\d+) but this ck-mc build only knows up to v(\d+)/.exec(message);
+  if (!match)
+    return null;
+  return { dbVersion: Number(match[1]), binaryMax: Number(match[2]) };
+}
+function storeAheadOfBinaryFailure(error) {
+  let current = error;
+  const seen = new Set;
+  while (isRecord4(current) && !seen.has(current)) {
+    seen.add(current);
+    if (current instanceof StoreAheadOfBinaryError)
+      return current;
+    if (current.code === STORE_AHEAD_OF_BINARY_CODE) {
+      const versions = versionsFromDetail(current.detail) ?? versionsFromMessage(current.message);
+      return new StoreAheadOfBinaryError(versions, { cause: error });
+    }
+    current = current.cause;
+  }
+  return null;
+}
+var STORE_AHEAD_OF_BINARY_CODE = "store_ahead_of_binary", StoreAheadOfBinaryError;
+var init_store_ahead_refusal = __esm(() => {
+  init_user_facing_codes();
+  StoreAheadOfBinaryError = class StoreAheadOfBinaryError extends Error {
+    code = STORE_AHEAD_OF_BINARY_CODE;
+    versions;
+    constructor(versions, options) {
+      super(renderStoreAheadOfBinaryRefusal(versions), options);
+      this.name = "StoreAheadOfBinaryError";
+      this.versions = versions;
+    }
+  };
+});
+
 // ../plugin/src/hooks/magic-context/module-transport.ts
 import { realpathSync as realpathSync3 } from "node:fs";
 import { join as join17 } from "node:path";
@@ -26676,7 +27382,8 @@ class SubcModuleTransport {
     const laneDeadlineMs = Date.now() + attemptTimeoutMs;
     let releaseLane = () => {};
     try {
-      if (!args.bypassSessionLane) {
+      const outsideSessionOrder = args.method.startsWith("historian.");
+      if (!args.bypassSessionLane && !outsideSessionOrder) {
         releaseLane = await this.acquireCorrectnessLane(args.sessionId, args.signal, laneDeadlineMs);
       }
     } catch (error) {
@@ -26736,6 +27443,9 @@ class SubcModuleTransport {
         } catch (error) {
           if (args.signal?.aborted)
             throw args.signal.reason ?? error;
+          const storeAhead = storeAheadOfBinaryFailure(error);
+          if (storeAhead)
+            throw storeAhead;
           if (args.method === "state_sync" && isDeadlineFailure(error)) {
             const body = isRecord3(args.body) ? args.body : {};
             throw Object.assign(new Error(`state_sync timeout stage=module_ack page=${body.seed_batch_index ?? 0}/${body.seed_batch_total ?? 1} series=${body.seed_id ?? "delta"} budget_ms=${attemptTimeoutMs}`), {
@@ -27049,6 +27759,7 @@ var DEFAULT_MODULE_ID = "magic-context", CONNECT_BACKOFF_INITIAL_MS = 1000, CONN
 var init_module_transport = __esm(() => {
   init_dist5();
   init_data_path();
+  init_store_ahead_refusal();
 });
 // ../plugin/src/shared/pi-executable.ts
 function piHarnessKindFromExecutable(value) {
@@ -27064,7 +27775,10 @@ 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 isOwnRpcServerRecord(record) {
+  return record.pid === process.pid && record.instance_id !== undefined && ownRpcServerInstanceIds.has(record.instance_id);
+}
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return "dead";
@@ -27587,10 +28301,11 @@ function parseRpcPortFile(content, fallbackPid = 0) {
 function isValidPort(port) {
   return Number.isInteger(port) && port > 0 && port <= 65535;
 }
-var RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, WINDOWS_CIM_PROBE_TIMEOUT_MS = 5000, MAX_ANCESTOR_WALK_DEPTH = 16, OPEN_CODE_COMMAND_MARKERS, TASKLIST_NO_TASKS_PATTERN, WINDOWS_CIM_COMMAND = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress", PI_HARNESS_ARC_MARKERS, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now(), windowsProcessFactsCache = null;
+var ownRpcServerInstanceIds, RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, WINDOWS_CIM_PROBE_TIMEOUT_MS = 5000, MAX_ANCESTOR_WALK_DEPTH = 16, OPEN_CODE_COMMAND_MARKERS, TASKLIST_NO_TASKS_PATTERN, WINDOWS_CIM_COMMAND = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress", PI_HARNESS_ARC_MARKERS, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now(), windowsProcessFactsCache = null;
 var init_rpc_utils = __esm(() => {
   init_logger();
   init_pi_executable();
+  ownRpcServerInstanceIds = new Set;
   OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
   TASKLIST_NO_TASKS_PATTERN = /^INFO:\s+No tasks are running which match the specified criteria\.?$/im;
   PI_HARNESS_ARC_MARKERS = [
@@ -27600,7 +28315,7 @@ var init_rpc_utils = __esm(() => {
     "cljs/dist",
     "dist/bundle/cli"
   ];
-  rpcIdentityReadFileSync = readFileSync13;
+  rpcIdentityReadFileSync = readFileSync14;
   rpcIdentityExecFileSync = execFileSync4;
   rpcIdentityProcessKill = process.kill;
   rpcProcessListExecFileSync = execFileSync4;
@@ -27720,7 +28435,9 @@ function formatFailClosedBlockingMessage(reason) {
     }
     return [
       `Magic Context cannot migrate the shared database (one database serves every project on this machine) because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
+      `The database is at upstream migration v${reason.persistedVersion}; this build needs v${reason.supportedVersion}.`,
       "Restart the blocking process — even one from a different project — and it will pick up the new build and migrate on start; or shut it down and retry.",
+      "If that host loads a pinned or cached older Magic Context build, a restart alone is not enough: stop it or update its Magic Context build, then start this host once so it migrates the database with nothing older attached.",
       `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
     ].join(" ");
   }
@@ -27755,6 +28472,47 @@ var init_message_fts_rowid_map = __esm(() => {
   activeBackfills = new WeakMap;
 });
 
+// ../plugin/src/features/magic-context/memory/constants.ts
+var V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, MEMORY_CATEGORY_ORDER_UNKNOWN = 99, MEMORY_CATEGORY_ORDER_PRIORITY, MEMORY_CATEGORY_ORDER_SQL, CATEGORY_DEFAULT_TTL;
+var init_constants = __esm(() => {
+  V2_MEMORY_CATEGORIES = [
+    "PROJECT_RULES",
+    "ARCHITECTURE",
+    "CONSTRAINTS",
+    "CONFIG_VALUES",
+    "NAMING"
+  ];
+  PROMOTABLE_CATEGORIES = [
+    ...V2_MEMORY_CATEGORIES,
+    "ARCHITECTURE_DECISIONS",
+    "CONFIG_DEFAULTS",
+    "USER_PREFERENCES",
+    "USER_DIRECTIVES",
+    "ENVIRONMENT",
+    "WORKFLOW_RULES",
+    "KNOWN_ISSUES"
+  ];
+  CATEGORY_PRIORITY = [
+    ...V2_MEMORY_CATEGORIES,
+    "USER_DIRECTIVES",
+    "USER_PREFERENCES",
+    "CONFIG_DEFAULTS",
+    "ARCHITECTURE_DECISIONS",
+    "ENVIRONMENT",
+    "WORKFLOW_RULES",
+    "KNOWN_ISSUES"
+  ];
+  MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
+    acc[category] = index;
+    return acc;
+  }, {});
+  MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
+  CATEGORY_DEFAULT_TTL = {
+    WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
+    KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
+  };
+});
+
 // ../plugin/src/hooks/magic-context/compartment-parser.ts
 function makeTierOpenRegex(n) {
   return new RegExp(`<p${n}\\s*(/?)>`);
@@ -27784,6 +28542,8 @@ function extractTiersFromInner(inner) {
 function parseCompartmentOutput(text) {
   const compartments = [];
   const facts = [];
+  let droppedFactBlocks = 0;
+  let droppedFacts = 0;
   for (const match of text.matchAll(COMPARTMENT_REGEX)) {
     const attrs = match[1];
     const inner = match[2];
@@ -27833,16 +28593,21 @@ function parseCompartmentOutput(text) {
     }
   }
   const factsBlockMatch = text.match(FACTS_BLOCK_REGEX);
-  const factsScope = factsBlockMatch ? factsBlockMatch[1] : text.replace(EVENTS_BLOCK_REGEX, "").replace(/<compartment\s+[^>]*?\s*>.*?<\/compartment>/gs, "");
+  const factsScope = factsBlockMatch ? factsBlockMatch[1] : text.replace(EVENTS_BLOCK_REGEX, "").replace(/<compartment\s+[^>]*?\s*>.*?<\/compartment>/gs, "").replace(/<(meta|user_observations|primer_candidates)>.*?<\/\1>/gs, "").replace(/<\/?(?:output|compartments)>/g, "");
   for (const categoryMatch of factsScope.matchAll(CATEGORY_BLOCK_REGEX)) {
     const category = categoryMatch[1];
     const blockContent = categoryMatch[2];
-    for (const itemMatch of blockContent.matchAll(FACT_ITEM_REGEX)) {
-      const content = unescapeXml(itemMatch[1].trim());
-      if (content) {
-        facts.push({ category, content });
-      }
+    const items = [...blockContent.matchAll(FACT_ITEM_REGEX)].map((match) => unescapeXml(match[1].trim())).filter(Boolean);
+    if (!HISTORIAN_CATEGORIES.has(category)) {
+      if (items.length === 0)
+        continue;
+      droppedFactBlocks++;
+      droppedFacts += items.length;
+      log3(`[historian] Dropped <facts> category ${category} (${items.length} facts)`);
+      continue;
     }
+    for (const content of items)
+      facts.push({ category, content });
   }
   const unprocessedMatch = text.match(UNPROCESSED_REGEX);
   const unprocessedFrom = unprocessedMatch ? parseInt(unprocessedMatch[1], 10) : null;
@@ -27880,7 +28645,16 @@ function parseCompartmentOutput(text) {
   }
   const events = parseEvents(text);
   compartments.sort((a, b) => a.startMessage - b.startMessage);
-  return { compartments, facts, events, unprocessedFrom, userObservations, primerCandidates };
+  return {
+    compartments,
+    facts,
+    droppedFactBlocks,
+    droppedFacts,
+    events,
+    unprocessedFrom,
+    userObservations,
+    primerCandidates
+  };
 }
 function parseEvents(text) {
   const blockMatch = text.match(EVENTS_BLOCK_REGEX);
@@ -27906,8 +28680,10 @@ function parseEvents(text) {
 function unescapeXml(s) {
   return s.replace(/&amp;/g, "&").replace(/&apos;/g, "'").replace(/&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">");
 }
-var COMPARTMENT_REGEX, ATTR_START_REGEX, ATTR_END_REGEX, ATTR_TITLE_REGEX, ATTR_EPISODE_REGEX, ATTR_IMPORTANCE_REGEX, TIER_OPEN_REGEXES, TIER_CLOSE_ANY_REGEX, TIER_OPEN_ANY_REGEX, CATEGORY_BLOCK_REGEX, FACT_ITEM_REGEX, UNPROCESSED_REGEX, USER_OBSERVATIONS_REGEX, USER_OBS_ITEM_REGEX, PRIMER_CANDIDATES_REGEX, PRIMER_ELEMENT_REGEX, PRIMER_ITEM_REGEX, FACTS_BLOCK_REGEX, EVENTS_BLOCK_REGEX, EVENT_ELEMENT_REGEX, EVENT_FIELD_REGEX;
+var COMPARTMENT_REGEX, ATTR_START_REGEX, ATTR_END_REGEX, ATTR_TITLE_REGEX, ATTR_EPISODE_REGEX, ATTR_IMPORTANCE_REGEX, TIER_OPEN_REGEXES, TIER_CLOSE_ANY_REGEX, TIER_OPEN_ANY_REGEX, CATEGORY_BLOCK_REGEX, HISTORIAN_CATEGORIES, FACT_ITEM_REGEX, UNPROCESSED_REGEX, USER_OBSERVATIONS_REGEX, USER_OBS_ITEM_REGEX, PRIMER_CANDIDATES_REGEX, PRIMER_ELEMENT_REGEX, PRIMER_ITEM_REGEX, FACTS_BLOCK_REGEX, EVENTS_BLOCK_REGEX, EVENT_ELEMENT_REGEX, EVENT_FIELD_REGEX;
 var init_compartment_parser = __esm(() => {
+  init_constants();
+  init_logger();
   COMPARTMENT_REGEX = /<compartment\s+([^>]*?)\s*>(.*?)<\/compartment>/gs;
   ATTR_START_REGEX = /\bstart="(\d+)"/;
   ATTR_END_REGEX = /\bend="(\d+)"/;
@@ -27922,7 +28698,8 @@ var init_compartment_parser = __esm(() => {
   ];
   TIER_CLOSE_ANY_REGEX = /<\/p\d/;
   TIER_OPEN_ANY_REGEX = /<p\d/;
-  CATEGORY_BLOCK_REGEX = /<(PROJECT_RULES|ARCHITECTURE|CONSTRAINTS|CONFIG_VALUES|NAMING)>(.*?)<\/\1>/gs;
+  CATEGORY_BLOCK_REGEX = /<([A-Za-z_][A-Za-z0-9_-]*)>(.*?)<\/\1>/gs;
+  HISTORIAN_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
   FACT_ITEM_REGEX = /^\s*\*\s*(.+)$/gm;
   UNPROCESSED_REGEX = /<unprocessed_from>(\d+)<\/unprocessed_from>/;
   USER_OBSERVATIONS_REGEX = /<user_observations>(.*?)<\/user_observations>/s;
@@ -28289,41 +29066,6 @@ function healMissingMemoryBlockIds(db, columns) {
   db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE memory_block_cache != '' AND (memory_block_ids IS NULL OR memory_block_ids = '') AND memory_block_count > 0").run();
 }
 
-// ../plugin/src/features/magic-context/memory/constants.ts
-var V2_MEMORY_CATEGORIES, CATEGORY_PRIORITY, MEMORY_CATEGORY_ORDER_UNKNOWN = 99, MEMORY_CATEGORY_ORDER_PRIORITY, MEMORY_CATEGORY_ORDER_SQL, CATEGORY_DEFAULT_TTL;
-var init_constants = __esm(() => {
-  V2_MEMORY_CATEGORIES = [
-    "PROJECT_RULES",
-    "ARCHITECTURE",
-    "CONSTRAINTS",
-    "CONFIG_VALUES",
-    "NAMING"
-  ];
-  CATEGORY_PRIORITY = [
-    "PROJECT_RULES",
-    "ARCHITECTURE",
-    "CONSTRAINTS",
-    "CONFIG_VALUES",
-    "NAMING",
-    "USER_DIRECTIVES",
-    "USER_PREFERENCES",
-    "CONFIG_DEFAULTS",
-    "ARCHITECTURE_DECISIONS",
-    "ENVIRONMENT",
-    "WORKFLOW_RULES",
-    "KNOWN_ISSUES"
-  ];
-  MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
-    acc[category] = index;
-    return acc;
-  }, {});
-  MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
-  CATEGORY_DEFAULT_TTL = {
-    WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
-    KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
-  };
-});
-
 // ../plugin/src/features/magic-context/project-identity.ts
 var init_project_identity2 = __esm(() => {
   init_project_identity();
@@ -30803,6 +31545,20 @@ var init_migrations = __esm(async () => {
           return;
         ensureColumn(db, "compartment_state_lease", "owner_pid", "INTEGER");
       }
+    },
+    {
+      version: 91,
+      description: "per-project embedding high-water mark for memories written outside this host",
+      up(db) {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS memory_embedding_watermarks (
+                    project_path TEXT PRIMARY KEY,
+                    written_memory_id INTEGER NOT NULL DEFAULT 0,
+                    embedded_memory_id INTEGER NOT NULL DEFAULT 0,
+                    updated_at INTEGER NOT NULL DEFAULT 0
+                );
+            `);
+      }
     }
   ];
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -30892,14 +31648,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;
@@ -31034,6 +31790,8 @@ function inspectRpcServerDiscovery(storageDir) {
         return junk;
       continue;
     }
+    if (isOwnRpcServerRecord(record))
+      continue;
     const liveness = isPidAlive(record.pid);
     if (liveness === "dead") {
       staleFiles.push(portFile);
@@ -31655,6 +32413,15 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       (id, cursor_session_id, cursor_ordinal, completed, updated_at)
     VALUES (1, '', 0, 0, 0);
 
+    -- Highest memory id another writer (the Rust module in single-store mode) put
+    -- into memories for a project, and how far this host has embedded. Migration v91.
+    CREATE TABLE IF NOT EXISTS memory_embedding_watermarks (
+      project_path TEXT PRIMARY KEY,
+      written_memory_id INTEGER NOT NULL DEFAULT 0,
+      embedded_memory_id INTEGER NOT NULL DEFAULT 0,
+      updated_at INTEGER NOT NULL DEFAULT 0
+    );
+
     CREATE TABLE IF NOT EXISTS message_history_index (
       session_id TEXT PRIMARY KEY,
       last_indexed_ordinal INTEGER NOT NULL DEFAULT 0,
@@ -32314,7 +33081,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     `);
   ensureColumn(db, "workspaces", "share_categories", `TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'`);
 }
-var databases, pendingAsyncOpens, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, LATEST_SUPPORTED_VERSION = 90, BOOT_SQLITE_BUSY_TIMEOUT_MS = 5000, PERMISSIONS_ENFORCEABLE, RPC_DISCOVERY_PARSE_GRACE_MS, defaultRpcDiscoveryFs, rpcDiscoveryFs, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS;
+var databases, pendingAsyncOpens, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, LATEST_SUPPORTED_VERSION = 91, BOOT_SQLITE_BUSY_TIMEOUT_MS = 5000, PERMISSIONS_ENFORCEABLE, RPC_DISCOVERY_PARSE_GRACE_MS, defaultRpcDiscoveryFs, rpcDiscoveryFs, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
@@ -32338,8 +33105,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)
   };
@@ -32352,13 +33119,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 });
@@ -32969,16 +33736,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";
@@ -33011,11 +33778,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}`);
@@ -33029,7 +33796,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);
@@ -33097,7 +33864,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
@@ -33116,7 +33883,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
@@ -33143,7 +33910,7 @@ function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath)
   } finally {
     if (dumpWriteFd !== null)
       closeSync4(dumpWriteFd);
-    rmSync2(dumpPath, { force: true });
+    rmSync3(dumpPath, { force: true });
   }
 }
 function migrateAndCheckRecoveredDatabase(path) {
@@ -33222,14 +33989,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);
@@ -33239,7 +34006,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;
@@ -33275,7 +34042,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");
@@ -33562,7 +34329,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();
@@ -33574,7 +34341,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);
@@ -34522,7 +35289,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) {
@@ -34741,7 +35508,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)
   };
 }
@@ -34820,7 +35587,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;
   }
@@ -35099,7 +35866,7 @@ async function doctorRetryV22Backfill(db) {
           bumpProjectMemoryEpochInTransaction(db, identity, now);
           succeeded += 1;
         }
-      })();
+      }).immediate();
     } catch (error) {
       const classified = classifyBackfillError(error);
       db.prepare(`UPDATE v22_backfill_failures
@@ -35132,7 +35899,7 @@ async function doctorRekeyV22DirIdentity(db, rawProjectPath) {
     if (changedRows > 0) {
       bumpProjectMemoryEpochInTransaction(db, newIdentity, now);
     }
-  })();
+  }).immediate();
   return { oldIdentity, newIdentity, changedRows };
 }
 var BACKFILL_META_KEY = "v22_legacy_memory_backfill", BACKFILL_CURSOR_META_KEY = "v22_legacy_memory_backfill_cursor", MEMORIES_TABLE = "memories";
@@ -35205,226 +35972,6 @@ var init_v22_backfill_commands = __esm(async () => {
   await init_storage_db();
 });
 
-// ../plugin/src/shared/user-facing-codes.ts
-function userFacingFailureCode(key) {
-  return USER_FACING_FAILURES[key].code;
-}
-var USER_FACING_FAILURES;
-var init_user_facing_codes = __esm(() => {
-  USER_FACING_FAILURES = {
-    historian_unavailable: {
-      code: "MC-H01",
-      sentence: "History compression could not finish this turn.",
-      action: "It will retry automatically."
-    },
-    hidden_cleanup_unbound: {
-      code: "MC-H02",
-      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."
-    },
-    recomp_unavailable: {
-      code: "MC-R01",
-      sentence: "History compression could not be rebuilt.",
-      action: "Run /ctx-recomp again."
-    },
-    dream_provider_timeout: {
-      code: "MC-D01",
-      sentence: "Memory maintenance took too long to respond.",
-      action: "Run /ctx-dream again."
-    },
-    dream_provider_error: {
-      code: "MC-D02",
-      sentence: "Memory maintenance could not reach its model.",
-      action: "Check the model connection, then run /ctx-dream again."
-    },
-    dream_empty_completion: {
-      code: "MC-D03",
-      sentence: "Memory maintenance received no usable response.",
-      action: "Run /ctx-dream again."
-    },
-    dream_no_models: {
-      code: "MC-D04",
-      sentence: "Memory maintenance has no model available.",
-      action: "Check the model settings, then run /ctx-dream again."
-    },
-    dream_child_aborted: {
-      code: "MC-D05",
-      sentence: "Memory maintenance was interrupted.",
-      action: "Run /ctx-dream again."
-    },
-    dream_parse_failed: {
-      code: "MC-D06",
-      sentence: "Memory maintenance could not use the model response.",
-      action: "Run /ctx-dream again."
-    },
-    dream_unknown: {
-      code: "MC-D07",
-      sentence: "Memory maintenance could not finish.",
-      action: "Run /ctx-dream again."
-    },
-    dreamer_tick_blocked: {
-      code: "MC-D09",
-      sentence: "Background maintenance is not running: its last pass stopped before it reached the scheduled tasks.",
-      action: "It is retried automatically; if it keeps happening, check the Magic Context log for the stage that stopped and run `npx @cortexkit/magic-context doctor`."
-    },
-    dream_task_needs_tool_loop: {
-      code: "MC-D08",
-      sentence: "Some memory maintenance tasks need a tool loop this host does not provide.",
-      action: "The remaining tasks still run; the listed ones are skipped on this host."
-    },
-    embedding_substitution_rejected: {
-      code: "MC-E01",
-      sentence: "Search indexing could not use the selected model.",
-      action: "Check the embedding model setting, then run /ctx-embed start again."
-    },
-    embedding_http_error: {
-      code: "MC-E02",
-      sentence: "The search indexing provider refused the request.",
-      action: "Check the provider connection and credentials, then run /ctx-embed start again."
-    },
-    embedding_transport_error: {
-      code: "MC-E03",
-      sentence: "Search indexing could not reach its provider.",
-      action: "Check the connection, then run /ctx-embed start again."
-    },
-    embedding_invalid_envelope: {
-      code: "MC-E04",
-      sentence: "Search indexing received an unsupported response.",
-      action: "Check the embedding endpoint, then run /ctx-embed start again."
-    },
-    embedding_empty_result: {
-      code: "MC-E05",
-      sentence: "Search indexing received no usable result.",
-      action: "Run /ctx-embed start again."
-    },
-    embedding_certification_refusal: {
-      code: "MC-E06",
-      sentence: "Search indexing is not ready for this provider.",
-      action: "Finish the provider setup, or set a fallback provider in the embedding settings, then run /ctx-embed start again."
-    },
-    embedding_credential_required: {
-      code: "MC-E07",
-      sentence: "Search indexing needs provider credentials.",
-      action: "Sign in to the provider, then run /ctx-embed start again."
-    },
-    embedding_local_binding_missing: {
-      code: "MC-E08",
-      sentence: "Local search indexing is unavailable on this system.",
-      action: "Run `npx @cortexkit/magic-context doctor`, then retry."
-    },
-    embedding_local_fs_unavailable: {
-      code: "MC-E09",
-      sentence: "Local search indexing cannot save its model files.",
-      action: "Update or reinstall Magic Context, then retry."
-    },
-    embedding_local_download_failure: {
-      code: "MC-E10",
-      sentence: "Local search indexing could not download its model.",
-      action: "Check the network connection, then retry."
-    },
-    embedding_local_runtime_error: {
-      code: "MC-E11",
-      sentence: "Local search indexing could not start.",
-      action: "Run `npx @cortexkit/magic-context doctor`, then retry."
-    },
-    embedding_unavailable: {
-      code: "MC-E12",
-      sentence: "Search indexing could not finish.",
-      action: "Run /ctx-embed start again."
-    },
-    status_unavailable: {
-      code: "MC-S01",
-      sentence: "Magic Context status is temporarily unavailable.",
-      action: "Retry /ctx-status in a moment."
-    },
-    transform_update_failed: {
-      code: "MC-S02",
-      sentence: "The last context update did not finish.",
-      action: "Send another message to retry."
-    },
-    configuration_warning: {
-      code: "MC-S03",
-      sentence: "Some configuration settings could not be applied.",
-      action: "Fix the configuration warning shown in /ctx-status, then restart."
-    },
-    status_log_unavailable: {
-      code: "MC-S04",
-      sentence: "Some diagnostic details could not be saved.",
-      action: "Retry /ctx-status in a moment."
-    },
-    memory_writes_paused: {
-      code: "MC-C01",
-      sentence: "Memory writes are paused while the engine syncs.",
-      action: "Retry in a moment."
-    },
-    memory_access_unavailable: {
-      code: "MC-C02",
-      sentence: "Memory access is temporarily unavailable.",
-      action: "Retry in a moment."
-    },
-    note_changes_paused: {
-      code: "MC-C03",
-      sentence: "Note changes are paused while the engine syncs.",
-      action: "Retry in a moment."
-    },
-    note_access_unavailable: {
-      code: "MC-C04",
-      sentence: "Notes are temporarily unavailable.",
-      action: "Retry in a moment."
-    },
-    context_cleanup_paused: {
-      code: "MC-C05",
-      sentence: "Context cleanup is paused while the engine syncs.",
-      action: "Retry in a moment."
-    },
-    partial_history_unavailable: {
-      code: "MC-C06",
-      sentence: "Partial history compression is not available in the current mode.",
-      action: "Run /ctx-recomp without a range."
-    },
-    smart_note_conditions_unavailable: {
-      code: "MC-C08",
-      sentence: "Conditional notes are not available in the current mode.",
-      action: "Save a regular note without a condition."
-    },
-    history_compression_paused: {
-      code: "MC-C09",
-      sentence: "History compression is paused while the engine syncs.",
-      action: "Retry in a moment."
-    },
-    context_service_unavailable: {
-      code: "MC-C10",
-      sentence: "Magic Context is temporarily unavailable.",
-      action: "Retry in a moment."
-    },
-    compaction_marker_missing: {
-      code: "MC-C11",
-      sentence: "The history boundary marker is missing from the OpenCode store, so requests carry the full session.",
-      action: "It is retried on every message; if this persists, run `/ctx-flush`."
-    },
-    memory_mirror_stalled: {
-      code: "MC-M01",
-      sentence: "Memory synchronization stopped before the host mirror caught up.",
-      action: "Send another message to resume it, or run `ck doctor drain-authority`."
-    },
-    memory_authority_mismatch: {
-      code: "MC-M02",
-      sentence: "Memory authority is inconsistent between the host and module.",
-      action: "Run `ck doctor drain-authority` before changing Rust mode."
-    },
-    rust_mode_unsupported: {
-      code: "MC-S06",
-      sentence: "Experimental Rust transform mode is not available on this OpenCode host.",
-      action: 'Magic Context is running its TypeScript mode instead; set `transform_mode` to "ts" to stop requesting Rust.'
-    },
-    dreamer_task_failing: {
-      code: "MC-S05",
-      sentence: "A background maintenance task keeps failing on its schedule.",
-      action: "Check the Magic Context log for the failing task and its error."
-    }
-  };
-});
-
 // ../plugin/src/features/magic-context/dreamer/tick-failure.ts
 function parseFailure(value) {
   if (!value)
@@ -35462,7 +36009,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`];
@@ -35472,10 +36019,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;
@@ -35770,7 +36317,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;
@@ -35779,7 +36326,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) {
@@ -35900,11 +36447,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"]
     });
@@ -35927,7 +36474,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,
@@ -35985,7 +36532,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) {
@@ -36282,11 +36829,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);
@@ -36313,7 +36860,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 };
       });
@@ -36362,10 +36909,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;
@@ -36407,10 +36954,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) };
@@ -36420,7 +36967,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;
@@ -36491,8 +37038,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 {
@@ -36501,7 +37048,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 {
@@ -36520,7 +37067,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;
@@ -36584,7 +37131,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;
@@ -36741,7 +37288,7 @@ var init_doctor_omp = __esm(async () => {
     now: () => new Date,
     inspectMagicContextLogs,
     execFileSync: execFileSync5,
-    spawnSync: spawnSync5
+    spawnSync: spawnSync6
   };
 });
 
@@ -37641,12 +38188,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;
@@ -37674,9 +38221,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
@@ -37724,9 +38271,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;
 }
@@ -37734,8 +38281,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] : [];
@@ -37787,7 +38334,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() {
@@ -37802,29 +38349,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;
   }
@@ -37836,10 +38406,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) {
@@ -37847,9 +38417,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;
@@ -37864,7 +38434,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) {
@@ -37897,10 +38467,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,
@@ -38049,7 +38619,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 [];
@@ -38083,7 +38653,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 [];
@@ -38145,6 +38715,9 @@ async function collectHistorianRuns(storageDirPath) {
     } catch {}
   }
 }
+function openCodeIssueLogHarnesses(hostGeneration) {
+  return hostGeneration === "v2" ? ["opencode2", "opencode"] : ["opencode"];
+}
 async function collectDiagnostics() {
   const pluginVersion = getSelfVersion();
   const configPaths = detectConfigPaths();
@@ -38154,8 +38727,6 @@ async function collectDiagnostics() {
   const storageResolution = getStorageResolution();
   const storageDirPath = storageResolution.path;
   const contextDbPath = join26(storageDirPath, "context.db");
-  const logFiles = inspectMagicContextLogs("opencode");
-  const primaryLog = logFiles.find((file) => file.exists) ?? logFiles[0];
   let compactionEnabled = false;
   try {
     compactionEnabled = isCompactionEnabled(loadPluginConfig(process.cwd()));
@@ -38165,6 +38736,8 @@ async function collectDiagnostics() {
   const opencodeInstallations = describeOpenCodeInstallations(detectOpenCodeInstallations());
   const activeInstallation = opencodeInstallations[0];
   const hostGeneration = openCodeHostGenerationFromVersion(activeInstallation?.version);
+  const logFiles = openCodeIssueLogHarnesses(hostGeneration).flatMap((harness) => inspectMagicContextLogs(harness)).filter((file, index, all) => all.findIndex((other) => other.path === file.path) === index);
+  const primaryLog = logFiles.find((file) => file.exists) ?? logFiles[0];
   const conflictResult = detectConflicts(process.cwd(), { compactionEnabled, hostGeneration });
   const openCodeDatabaseResolution = resolveOpenCodeDbPath(hostGeneration);
   const recentSessions = await collectRecentSessions(openCodeDatabaseResolution, hostGeneration);
@@ -38185,15 +38758,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: {
@@ -38240,7 +38813,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),
@@ -38356,6 +38934,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();
@@ -38419,8 +38998,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) {
@@ -38429,7 +39008,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"],
@@ -38567,7 +39146,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;
@@ -38616,7 +39195,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(", ")})`
@@ -38641,7 +39220,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);
@@ -38652,7 +39231,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,
@@ -38663,7 +39242,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",
@@ -38710,7 +39289,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);
@@ -38752,7 +39331,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,
@@ -39291,6 +39870,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(() => {
@@ -39312,14 +39892,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}`);
 }
@@ -39366,9 +39946,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) {
@@ -39404,14 +39984,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;
     }
@@ -39431,7 +40011,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;
@@ -39440,7 +40020,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);
@@ -39448,7 +40028,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);
       }
@@ -39462,7 +40042,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);
@@ -39665,6 +40245,179 @@ var init_storage_versions = __esm(async () => {
   await init_storage_db();
 });
 
+// src/commands/doctor-opencode-cache.ts
+import { existsSync as existsSync36, readFileSync as readFileSync25, rmSync as rmSync4 } from "node:fs";
+function readCachedPluginVersion(pluginCacheDir) {
+  try {
+    const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
+    if (!existsSync36(installedPkgPath))
+      return;
+    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) => rmSync4(path, { recursive: true, force: true }));
+  const pluginCacheRoots = getOpenCodePluginCacheRoots();
+  const existingRoots = pluginCacheRoots.filter((root) => existsSync36(root));
+  if (existingRoots.length === 0) {
+    return { action: "not_found", path: pluginCacheRoots[0] ?? "" };
+  }
+  const latestVersion = options.latestVersion ?? undefined;
+  const cacheEntries = existingRoots.map((path) => ({
+    path,
+    cached: readCachedPluginVersion(path)
+  }));
+  if (options.force !== true && latestVersion === undefined) {
+    const firstEntry = cacheEntries[0];
+    return {
+      action: "check_unavailable",
+      path: firstEntry?.path ?? pluginCacheRoots[0] ?? "",
+      paths: cacheEntries.map((entry) => entry.path),
+      cached: firstEntry?.cached
+    };
+  }
+  const clearTargets = cacheEntries.filter((entry) => options.force === true || entry.cached === undefined || entry.cached !== latestVersion);
+  if (clearTargets.length === 0) {
+    const firstEntry = cacheEntries[0];
+    return {
+      action: "up_to_date",
+      path: firstEntry?.path ?? pluginCacheRoots[0] ?? "",
+      paths: cacheEntries.map((entry) => entry.path),
+      cached: firstEntry?.cached,
+      latest: latestVersion
+    };
+  }
+  const cleared = [];
+  const failed = [];
+  for (const entry of clearTargets) {
+    try {
+      remove(entry.path);
+      cleared.push(entry);
+    } catch (err) {
+      failed.push({
+        path: entry.path,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (failed.length > 0) {
+    const firstFailure = failed[0];
+    return {
+      action: "error",
+      path: firstFailure?.path ?? clearTargets[0]?.path ?? existingRoots[0] ?? "",
+      paths: failed.map((entry) => entry.path),
+      clearedPaths: cleared.map((entry) => entry.path),
+      failedPaths: failed.map((entry) => entry.path),
+      error: firstFailure?.error
+    };
+  }
+  const firstTarget = cleared[0];
+  return {
+    action: "cleared",
+    path: firstTarget?.path ?? pluginCacheRoots[0] ?? "",
+    paths: cleared.map((entry) => entry.path),
+    cached: firstTarget?.cached,
+    latest: latestVersion
+  };
+}
+var init_doctor_opencode_cache = __esm(() => {
+  init_opencode_plugin_cache();
+});
+
+// src/commands/doctor-cached-plugin-fence.ts
+import { existsSync as existsSync37 } from "node:fs";
+import { dirname as dirname18 } from "node:path";
+function listCachedOpenCodePluginFences(sources = {}) {
+  const fences = [];
+  for (const root of sources.openCodeV1Roots ?? getOpenCodePluginCacheRoots()) {
+    const packageJson = getOpenCodePluginPackageJsonPath(root);
+    if (!existsSync37(packageJson))
+      continue;
+    fences.push({
+      host: "opencode1",
+      directory: root,
+      version: readCachedPluginVersion(root),
+      supportedVersion: readFenceFromDist(dirname18(packageJson))
+    });
+  }
+  for (const slot of listOpenCodeV2PluginCacheSlots(sources.openCodeV2NpmCacheDir)) {
+    if (!isOpenCodePluginDistTag(slot.spec))
+      continue;
+    const generation = getOpenCodeV2ActiveGeneration(slot.slot);
+    if (!generation)
+      continue;
+    fences.push({
+      host: "opencode2",
+      directory: slot.slot,
+      spec: slot.spec,
+      version: slot.version,
+      supportedVersion: readFenceFromDist(dirname18(getOpenCodePluginPackageJsonPath(generation)))
+    });
+  }
+  return fences;
+}
+function readContextDbSchemaVersion(path) {
+  let db = null;
+  try {
+    db = openExistingDatabase(path, { readonly: true });
+    return db === null ? null : getPersistedSchemaVersion(db);
+  } catch {
+    return null;
+  } finally {
+    db?.close();
+  }
+}
+function compareCachedPluginFences(fences, databaseVersion) {
+  return fences.map((fence) => ({
+    ...fence,
+    databaseVersion,
+    status: fence.supportedVersion === null ? "unknown" : fence.supportedVersion < databaseVersion ? "behind" : "supported"
+  }));
+}
+function hostLabel(fence) {
+  if (fence.host === "opencode1")
+    return "OpenCode 1";
+  return fence.spec && fence.spec !== "latest" ? `OpenCode 2 (@${fence.spec})` : "OpenCode 2";
+}
+function reportCachedPluginFences(findings, report) {
+  const supported = [];
+  let behind = 0;
+  for (const finding of findings) {
+    const label = hostLabel(finding);
+    const version = finding.version ?? "unknown version";
+    if (finding.status === "supported") {
+      supported.push(`${label} ${version} (fence v${finding.supportedVersion})`);
+      continue;
+    }
+    if (finding.status === "unknown") {
+      report.info(`${label} plugin cache: could not read the schema fence of Magic Context ${version}, so doctor cannot tell whether it supports context.db v${finding.databaseVersion}`);
+      report.info(`  ${finding.directory}`);
+      continue;
+    }
+    behind++;
+    report.fail(`${label} has Magic Context ${version} cached, which supports context.db only through schema v${finding.supportedVersion}, but the shared context.db is at v${finding.databaseVersion}. A newer Magic Context (usually the other OpenCode host) migrated it, so ${label} fails closed on every prompt; an @latest entry does not refresh this cached copy.`);
+    report.info(`  ${finding.directory}`);
+    report.info(finding.host === "opencode1" ? "  To fix: quit OpenCode 1 and delete that directory; OpenCode 1 installs the current release on its next start." : `  To fix, ${OPENCODE_V2_PLUGIN_UPDATE_HINT}, then restart OpenCode 2.`);
+  }
+  if (supported.length > 0) {
+    report.pass(`Cached Magic Context copies support context.db v${findings[0]?.databaseVersion}: ${supported.join(", ")}`);
+  }
+  return { behind };
+}
+var init_doctor_cached_plugin_fence = __esm(async () => {
+  init_opencode_plugin_cache();
+  init_opencode_plugin_schema_fence();
+  init_doctor_opencode_cache();
+  init_doctor_opencode2_cache();
+  await __promiseAll([
+    init_storage_db(),
+    init_database_access()
+  ]);
+});
+
 // src/commands/doctor-compaction-markers.ts
 function safeData(column = "data") {
   return `CASE WHEN json_valid(${column}) THEN ${column} ELSE '{}' END`;
@@ -39720,6 +40473,21 @@ function countUnmatchedConvertedMarkers(db, migratedV2Schema) {
                 )`).get();
   return Number(row?.count ?? 0);
 }
+function countPostConversionMessages(db, migratedV2Schema) {
+  if (!migratedV2Schema || !tableExists4(db, "message") || !tableExists4(db, "session")) {
+    return { messages: 0, sessions: 0 };
+  }
+  const row = db.prepare(`SELECT COUNT(*) AS messages, COUNT(DISTINCT converted.session_id) AS sessions
+               FROM session_message converted
+              WHERE EXISTS (SELECT 1 FROM session legacy WHERE legacy.id = converted.session_id)
+                AND NOT EXISTS (
+                    SELECT 1
+                      FROM message source
+                     WHERE source.session_id = converted.session_id
+                       AND source.time_created = converted.time_created
+                )`).get();
+  return { messages: Number(row?.messages ?? 0), sessions: Number(row?.sessions ?? 0) };
+}
 function checkOpenCodeCompactionMarkerConversion(db, options = {}) {
   const missingBefore = countMissingCompleted(db);
   let repaired = 0;
@@ -39740,6 +40508,7 @@ function checkOpenCodeCompactionMarkerConversion(db, options = {}) {
   const migratedV2Schema = tableExists4(db, "session_v2") && tableExists4(db, "session_message");
   const migrationCompleted = migrationV1ToV2Completed(db);
   const unmatchedConvertedMarkers = countUnmatchedConvertedMarkers(db, migratedV2Schema);
+  const postConversion = countPostConversionMessages(db, migratedV2Schema);
   return {
     missingBefore,
     missingAfter,
@@ -39747,21 +40516,23 @@ function checkOpenCodeCompactionMarkerConversion(db, options = {}) {
     migrationCompleted,
     migratedV2Schema,
     unmatchedConvertedMarkers,
-    recoveryRequired: migrationCompleted && migratedV2Schema && unmatchedConvertedMarkers > 0
+    postConversionMessages: postConversion.messages,
+    postConversionSessions: postConversion.sessions
   };
 }
 function formatOpenCodeCompactionMarkerConversion(report) {
   return `OpenCode compaction markers are convertible to OpenCode 2: before=${report.missingBefore} missing time.completed; after=${report.missingAfter}`;
 }
-function formatOpenCodeV2ReconversionRecipe(databasePath) {
-  return [
-    "OpenCode 2 already completed its v1→v2 conversion, but one or more Magic Context markers are absent from session_message.",
-    "Recovery (with every OpenCode host stopped): clear only the kv.migration.v1-v2 marker, then restart the host once so it reconverts the v1 rows. Do not edit session_v2 or session_message by hand.",
-    `Database: ${databasePath}`,
-    "In sqlite3, run: DELETE FROM kv WHERE key = 'migration.v1-v2';",
-    "Large-store conversion can take several minutes. `opencode service start` may kill the server as unresponsive while it runs; start `opencode serve --port N` by hand instead.",
-    'Wait until `SELECT value FROM kv WHERE key = \'migration.v1-v2\';` reads `{"phase":"completed"}` before stopping that manual server'
+function formatOpenCodeV2MissingMarkerNotice(report) {
+  if (!report.migrationCompleted || !report.migratedV2Schema || report.unmatchedConvertedMarkers === 0) {
+    return null;
+  }
+  const lines = [
+    `OpenCode 2's conversion did not carry over ${report.unmatchedConvertedMarkers} Magic Context compaction marker(s). No action is needed.`,
+    "Magic Context on OpenCode 2 does not use host compaction rows: it keeps its own boundary and re-derives compartment positions from the messages that survived. OpenCode reads these sessions' full history on each turn, as it does for any Magic Context session started on OpenCode 2."
   ];
+  lines.push(report.postConversionMessages > 0 ? `Do not clear kv.migration.v1-v2 to reconvert: OpenCode 2 would rebuild every converted session from its OpenCode 1 rows and delete the ${report.postConversionMessages} message(s) it added after the conversion, in ${report.postConversionSessions} session(s).` : "Do not clear kv.migration.v1-v2 to reconvert: OpenCode 2 would rebuild every converted session from its OpenCode 1 rows, deleting anything added on OpenCode 2 since.", "If you already reconverted, restore opencode.db (with its -wal and -shm files) from a backup taken before the reconversion.");
+  return lines;
 }
 
 // src/commands/doctor-compartment-boundaries.ts
@@ -39845,86 +40616,175 @@ var init_doctor_harness_relabel = __esm(async () => {
   await init_opencode2_relabel();
 });
 
-// src/commands/doctor-opencode-cache.ts
-import { existsSync as existsSync35, readFileSync as readFileSync24, rmSync as rmSync3 } from "node:fs";
-function readCachedPluginVersion(pluginCacheDir) {
-  try {
-    const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
-    if (!existsSync35(installedPkgPath))
-      return;
-    const pkg = JSON.parse(readFileSync24(installedPkgPath, "utf-8"));
-    return typeof pkg.version === "string" ? pkg.version : undefined;
-  } catch {
-    return;
+// 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;
 }
-async function clearPluginCache(options = {}, deps = {}) {
-  const remove = deps.remove ?? ((path) => rmSync3(path, { recursive: true, force: true }));
-  const pluginCacheRoots = getOpenCodePluginCacheRoots();
-  const existingRoots = pluginCacheRoots.filter((root) => existsSync35(root));
-  if (existingRoots.length === 0) {
-    return { action: "not_found", path: pluginCacheRoots[0] ?? "" };
+function hasOptions(options) {
+  if (options === undefined || options === null)
+    return false;
+  if (typeof options === "object" && !Array.isArray(options)) {
+    return Object.keys(options).length > 0;
   }
-  const latestVersion = options.latestVersion ?? undefined;
-  const cacheEntries = existingRoots.map((path) => ({
-    path,
-    cached: readCachedPluginVersion(path)
-  }));
-  if (options.force !== true && latestVersion === undefined) {
-    const firstEntry = cacheEntries[0];
-    return {
-      action: "check_unavailable",
-      path: firstEntry?.path ?? pluginCacheRoots[0] ?? "",
-      paths: cacheEntries.map((entry) => entry.path),
-      cached: firstEntry?.cached
-    };
+  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) });
   }
-  const clearTargets = cacheEntries.filter((entry) => options.force === true || entry.cached === undefined || entry.cached !== latestVersion);
-  if (clearTargets.length === 0) {
-    const firstEntry = cacheEntries[0];
-    return {
-      action: "up_to_date",
-      path: firstEntry?.path ?? pluginCacheRoots[0] ?? "",
-      paths: cacheEntries.map((entry) => entry.path),
-      cached: firstEntry?.cached,
-      latest: latestVersion
-    };
+  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 cleared = [];
-  const failed = [];
-  for (const entry of clearTargets) {
-    try {
-      remove(entry.path);
-      cleared.push(entry);
-    } catch (err) {
-      failed.push({
-        path: entry.path,
-        error: err instanceof Error ? err.message : String(err)
-      });
+  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 (failed.length > 0) {
-    const firstFailure = failed[0];
-    return {
-      action: "error",
-      path: firstFailure?.path ?? clearTargets[0]?.path ?? existingRoots[0] ?? "",
-      paths: failed.map((entry) => entry.path),
-      clearedPaths: cleared.map((entry) => entry.path),
-      failedPaths: failed.map((entry) => entry.path),
-      error: firstFailure?.error
-    };
+  if (optionSets.length > 1) {
+    return { action: "leave", reason: "conflicting-options", entries };
   }
-  const firstTarget = cleared[0];
-  return {
-    action: "cleared",
-    path: firstTarget?.path ?? pluginCacheRoots[0] ?? "",
-    paths: cleared.map((entry) => entry.path),
-    cached: firstTarget?.cached,
-    latest: latestVersion
-  };
+  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 };
 }
-var init_doctor_opencode_cache = __esm(() => {
+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
@@ -39982,11 +40842,22 @@ 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 existsSync38, 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";
+function formatSharedDbRowCounts(db) {
+  return SHARED_DB_ROW_COUNT_TABLES.map((table) => {
+    try {
+      const row = db.prepare(`SELECT COUNT(*) AS c FROM ${table}`).get();
+      return `${table}=${typeof row?.c === "number" ? row.c : "n/a"}`;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return `${table}=n/a (${sanitizeDiagnosticText(reason)})`;
+    }
+  }).join(", ");
+}
 function findUndeclaredConfiguredVariants(configured, catalog) {
   return configured.filter((entry) => {
     const [providerID, id] = entry.model.split("/", 2);
@@ -39994,13 +40865,26 @@ 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 findUnknownConfiguredModels(configured, catalog) {
+  return configured.flatMap((entry) => {
+    const [providerID, id] = entry.model.split("/", 2);
+    if (!catalog.some((item) => item.providerID === providerID)) {
+      return [{ ...entry, unknown: "provider" }];
+    }
+    if (!catalog.some((item) => item.providerID === providerID && item.id === id)) {
+      return [{ ...entry, unknown: "model" }];
+    }
+    return [];
+  });
+}
+function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args, cwd) => spawnSync8("opencode", args, {
   cwd,
   encoding: "utf8",
   timeout: hostGeneration === "v2" ? 90000 : 45000,
   maxBuffer: 16 * 1024 * 1024
 }), projectDir = process.cwd()) {
   const configured = [];
+  const models = [];
   const root = config && typeof config === "object" ? config : {};
   for (const agent of ["historian", "dreamer"]) {
     const section = root[agent];
@@ -40010,21 +40894,25 @@ function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args
     if (!block || typeof block !== "object")
       continue;
     const record = block;
-    const add = (entry, defaultVariant) => {
+    const add = (entry, defaultVariant, fallback) => {
       const value = entry && typeof entry === "object" ? entry : {};
       const model = typeof entry === "string" ? entry : value.model;
       const variant = value.variant ?? defaultVariant;
-      if (typeof model === "string" && typeof variant === "string" && model.includes("/")) {
-        configured.push({ agent, model, variant });
+      if (typeof model !== "string" || !model.includes("/"))
+        return;
+      if (!models.some((known) => known.agent === agent && known.model === model)) {
+        models.push({ agent, model, fallback });
       }
+      if (typeof variant === "string")
+        configured.push({ agent, model, variant });
     };
-    add(record.model, record.variant);
+    add(record.model, record.variant, false);
     if (Array.isArray(record.fallback_models)) {
       for (const entry of record.fallback_models)
-        add(entry, undefined);
+        add(entry, undefined, true);
     }
   }
-  if (configured.length === 0)
+  if (models.length === 0)
     return;
   const tempRoot = mkdtempSync(join32(tmpdir3(), "magic-context-opencode-catalog-"));
   try {
@@ -40033,14 +40921,19 @@ function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args
     const result = run(command, tempRoot);
     const catalog = hostGeneration === "v2" ? parseOpenCodeV2ModelCatalog(result.stdout ?? "") : parseOpenCodeModelCatalog(result.stdout ?? "");
     if (result.error || result.status !== 0 || catalog.length === 0) {
-      warn(`Could not verify configured hidden-agent variants: this OpenCode host did not provide a readable model catalog. ${hostGeneration === "v2" ? "Start the background service with opencode service start, then check" : "Check"} ${guidance}.`);
+      warn(`Could not verify configured hidden-agent models and variants: this OpenCode host did not provide a readable model catalog. ${hostGeneration === "v2" ? "Start the background service with opencode service start, then check" : "Check"} ${guidance}.`);
       return;
     }
+    for (const entry of findUnknownConfiguredModels(models, catalog)) {
+      const [providerID] = entry.model.split("/", 1);
+      const role = `${entry.agent}${entry.fallback ? " fallback" : ""} model ${entry.model}`;
+      warn(entry.unknown === "provider" ? `${role} names provider '${providerID}', which this OpenCode host does not have. The ${entry.agent} cannot run on it; configure that provider in OpenCode or choose a model listed by ${guidance}.` : `${role} is not offered by provider '${providerID}' on this OpenCode host. The ${entry.agent} cannot run on it; choose a model listed by ${guidance}.`);
+    }
     for (const entry of findUndeclaredConfiguredVariants(configured, catalog)) {
       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) {
@@ -40159,12 +41052,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" }
       });
@@ -40179,6 +41072,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"]) {
@@ -40190,11 +41087,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;
@@ -40212,10 +41104,10 @@ function getUserNpmrcPath() {
 function collectNpmReleaseAgeWarnings() {
   const ageWarnings = [];
   const npmrcPath = getUserNpmrcPath();
-  if (!existsSync36(npmrcPath))
+  if (!existsSync38(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();
@@ -40248,15 +41140,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;
     }
@@ -40349,7 +41241,7 @@ function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync36(magicContextConfigPath)) {
+  if (!existsSync38(magicContextConfigPath)) {
     return checkLocalEmbeddingRuntimeForDoctor();
   }
   let rawText;
@@ -40557,7 +41449,7 @@ async function runDoctor2(options = {}) {
   const activeInstallation = installationReports[0];
   if (!activeInstallation) {
     fail("OpenCode is not installed or not in PATH");
-    log2.info("Doctor checked ~/.opencode/bin/opencode and each entry in $PATH.");
+    log2.info("Doctor checked ~/.opencode/bin/opencode, each entry in $PATH, and the OpenCode CLI bundled in OpenChamber.app.");
     log2.info("If `which opencode` succeeds outside doctor, your wrapper or shim may not be readable by Node — please share that wrapper in the issue.");
     outro2("Doctor failed — install OpenCode first");
     return 1;
@@ -40573,7 +41465,19 @@ async function runDoctor2(options = {}) {
     pass(installationReports.length > 1 ? `OpenCode ${activeInstallation.version} installed (active install marked above)` : `OpenCode ${activeInstallation.version} installed`);
   }
   const hostGeneration = openCodeHostGenerationFromVersion(activeInstallation.version);
-  const openCodeDbResolution = resolveOpenCodeDbPath(hostGeneration);
+  const storeHostSelection = selectOpenCodeStoreHost(installationReports, openCodeHostGenerationFromVersion);
+  const storeHost = storeHostSelection?.host ?? activeInstallation;
+  const storeGeneration = openCodeHostGenerationFromVersion(storeHost.version);
+  const openCodeDbResolution = resolveOpenCodeDbPath(storeGeneration);
+  if (storeHostSelection?.shadowed) {
+    const activeStore = resolveOpenCodeDbPath(hostGeneration).path;
+    const shared = activeStore === openCodeDbResolution.path;
+    const versionLabel = (version) => version.replace(/^opencode\s+v?/i, "");
+    const activeVersion = versionLabel(activeInstallation.version);
+    const storeVersion = versionLabel(storeHost.version);
+    warn(`OpenCode ${activeVersion} (${activeInstallation.path}) is first on PATH, and OpenCode ${storeVersion} is also installed (${storeHost.path})${shared ? `; both use ${openCodeDbResolution.path}` : ""}.`);
+    log2.warn(`  Store and conversion checks below use OpenCode ${storeVersion}. Plugin configuration checks use OpenCode ${activeVersion}; to check OpenCode ${storeVersion}'s configuration instead, put its binary first on PATH and run doctor again.`);
+  }
   const openCodeDbCheck = describeOpenCodeDatabaseDoctorCheck(openCodeDbResolution);
   if (openCodeDbCheck.ok)
     pass(openCodeDbCheck.message);
@@ -40597,14 +41501,16 @@ async function runDoctor2(options = {}) {
         fixed += report.repaired;
       } else if (options.fix) {
         warn(`${summary}; repaired=${report.repaired}, but some rows remain unconvertible`);
+      } else if (report.migrationCompleted) {
+        log2.info(`${summary}; OpenCode 2 already converted this store`);
       } else {
         warn(`${summary}; run \`magic-context doctor --fix\` before upgrading OpenCode`);
       }
-      if (report.recoveryRequired) {
-        const [heading, ...details] = formatOpenCodeV2ReconversionRecipe(openCodeDbResolution.path);
-        warn(heading ?? "OpenCode 2 conversion recovery is required");
-        for (const detail of details)
-          log2.warn(`  ${detail}`);
+      const notice = formatOpenCodeV2MissingMarkerNotice(report);
+      if (notice) {
+        for (const [index, line] of notice.entries()) {
+          log2.info(index === 0 ? line : `  ${line}`);
+        }
       }
     } catch (error) {
       warn(`OpenCode compaction marker conversion check unavailable: ${error instanceof Error ? error.message : String(error)}`);
@@ -40620,9 +41526,14 @@ async function runDoctor2(options = {}) {
           readonly: true,
           fileMustExist: true
         });
-        const dangling = listDanglingCompartmentBoundaries(contextDb, sessionDb, /\d/.test(activeInstallation.version) ? hostGeneration : undefined, (line) => log2.info(line));
+        const dangling = listDanglingCompartmentBoundaries(contextDb, sessionDb, /\d/.test(storeHost.version) ? storeGeneration : undefined, (line) => log2.info(line));
         if (dangling.length === 0) {
           pass("Compartment boundary ids resolve in the OpenCode session store");
+        } else if (storeGeneration === "v2" && /\d/.test(storeHost.version)) {
+          log2.info(`${dangling.length} compartment(s) point at OpenCode message ids that are not in the OpenCode 2 store. Magic Context places these from the neighbouring compartments; any it cannot place are listed as excluded from range recovery below.`);
+          for (const boundary of dangling) {
+            log2.info(`  ${formatDanglingCompartmentBoundary(boundary)}`);
+          }
         } else {
           warn(`${dangling.length} compartment(s) have dangling OpenCode boundary ids`);
           for (const boundary of dangling) {
@@ -40631,11 +41542,11 @@ async function runDoctor2(options = {}) {
         }
         if (!supportsCoordinateGenerationReporting(contextDb)) {
           log2.info("Store projection check: this context database predates the coordinate columns");
-        } else if (!/\d/.test(activeInstallation.version)) {
+        } else if (!/\d/.test(storeHost.version)) {
           log2.info("Store projection check: OpenCode reported no version, so the running projection is unknown");
         } else {
-          const pendingRebases = countPendingCoordinateRebases(contextDb, hostGeneration);
-          const pendingLine = formatPendingCoordinateRebases(pendingRebases, hostGeneration);
+          const pendingRebases = countPendingCoordinateRebases(contextDb, storeGeneration);
+          const pendingLine = formatPendingCoordinateRebases(pendingRebases, storeGeneration);
           if (pendingRebases.changed + pendingRebases.unrecorded === 0) {
             pass(pendingLine);
           } else {
@@ -40680,7 +41591,7 @@ async function runDoctor2(options = {}) {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
   let autoUpdateEnabled = true;
-  if (existsSync36(paths.magicContextConfig)) {
+  if (existsSync38(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
@@ -40716,7 +41627,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 (existsSync38(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -40846,59 +41757,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");
@@ -40939,25 +41826,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 (existsSync38(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 {
@@ -40966,13 +41846,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)}
 `);
@@ -40992,7 +41866,7 @@ async function runDoctor2(options = {}) {
       fail("Could not create or verify the TUI sidebar config");
     }
   }
-  if (existsSync36(paths.magicContextConfig)) {
+  if (existsSync38(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -41016,7 +41890,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 (!existsSync38(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}`);
@@ -41063,25 +41937,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
           fail(`SQLite integrity_check failed: ${err instanceof Error ? err.message : String(err)}
 ${formatDatabaseRepairGuidance(dbPath)}`);
         }
-        try {
-          const counts = {};
-          for (const table of [
-            "tags",
-            "compartments",
-            "memories",
-            "notes",
-            "dream_runs"
-          ]) {
-            try {
-              const row = db.prepare(`SELECT COUNT(*) as c FROM ${table}`).get();
-              counts[table] = row?.c ?? 0;
-            } catch {
-              counts[table] = 0;
-            }
-          }
-          const summary = Object.entries(counts).map(([k, v]) => `${k}=${v}`).join(", ");
-          log2.info(`Shared DB row counts: ${summary}`);
-        } catch {}
+        log2.info(`Shared DB row counts: ${formatSharedDbRowCounts(db)}`);
         for (const stall of listShadowBackfillStalls(db)) {
           warn(formatShadowBackfillStall(stall));
         }
@@ -41130,9 +41986,30 @@ ${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 sharedDbVersion = readContextDbSchemaVersion(dbPath);
+  if (sharedDbVersion !== null) {
+    reportCachedPluginFences(compareCachedPluginFences(listCachedOpenCodePluginFences(), sharedDbVersion), { pass, fail, info: (message) => log2.info(message) });
+  }
   {
     const ageWarnings = collectNpmReleaseAgeWarnings();
     if (ageWarnings.length > 0) {
@@ -41145,7 +42022,11 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
       issues++;
     }
   }
-  const logFiles = inspectMagicContextLogs("opencode");
+  const logHarnesses = [
+    ...hostGeneration === "v1" ? ["opencode"] : [],
+    ...hostGeneration === "v2" || storeGeneration === "v2" ? ["opencode2"] : []
+  ];
+  const logFiles = logHarnesses.flatMap((harness) => inspectMagicContextLogs(harness)).filter((file, index, all) => all.findIndex((other) => other.path === file.path) === index);
   const existingLogFiles = logFiles.filter((file) => file.exists);
   if (existingLogFiles.length === 0) {
     log2.info(`No plugin log file yet; checked: ${logFiles.map((file) => file.path).join(", ")}`);
@@ -41193,7 +42074,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   }
   return 0;
 }
-var import_comment_json11, CLI_PACKAGE_NAME = "@cortexkit/magic-context";
+var import_comment_json11, CLI_PACKAGE_NAME = "@cortexkit/magic-context", SHARED_DB_ROW_COUNT_TABLES;
 var init_doctor_opencode = __esm(async () => {
   init_config();
   init_agent_disable();
@@ -41227,6 +42108,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(),
@@ -41234,13 +42118,15 @@ var init_doctor_opencode = __esm(async () => {
     init_storage_versions(),
     init_v22_backfill_commands(),
     init_doctor_authority(),
+    init_doctor_cached_plugin_fence(),
     init_doctor_harness_relabel()
   ]);
   import_comment_json11 = __toESM(require_src3(), 1);
+  SHARED_DB_ROW_COUNT_TABLES = ["tags", "compartments", "memories", "notes", "dream_runs"];
 });
 
 // src/lib/diagnostics-pi.ts
-import { existsSync as existsSync37, readdirSync as readdirSync6, readFileSync as readFileSync26, statSync as statSync16 } from "node:fs";
+import { existsSync as existsSync39, 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() {
@@ -41257,7 +42143,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path) {
   try {
-    return existsSync37(path) ? statSync16(path).size : 0;
+    return existsSync39(path) ? statSync16(path).size : 0;
   } catch {
     return 0;
   }
@@ -41269,11 +42155,11 @@ function sanitizeValue2(value) {
   return sanitizeConfigValue(value);
 }
 function readJsonc(path) {
-  if (!existsSync37(path))
+  if (!existsSync39(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 {
@@ -41289,7 +42175,7 @@ function readConfigDiagnostic(path) {
   const parsed = readJsonc(path);
   return {
     path,
-    exists: existsSync37(path),
+    exists: existsSync39(path),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -41307,10 +42193,10 @@ function reverseSlugToDirectory(slug) {
 }
 function collectPiRecentSessions() {
   const sessionsRoot = getPiSessionsRoot();
-  if (!existsSync37(sessionsRoot))
+  if (!existsSync39(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);
@@ -41319,7 +42205,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;
       }
@@ -41343,7 +42229,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) {
@@ -41376,10 +42262,10 @@ function parseHistorianDumpMeta2(path) {
   }
 }
 function listDumpsInDir2(dir, limit) {
-  if (!existsSync37(dir))
+  if (!existsSync39(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,
@@ -41470,7 +42356,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync37(settingsPath),
+      exists: existsSync39(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasPiMagicContextPackage(packages),
       packages: sanitizeValue2(packages)
@@ -41487,7 +42373,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync37(storageDirPath),
+      exists: existsSync39(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -41593,7 +42479,7 @@ var init_diagnostics_pi = __esm(() => {
 
 // src/lib/logs-pi.ts
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname18, join as join34 } from "node:path";
+import { dirname as dirname19, join as join34 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
 }
@@ -41664,7 +42550,7 @@ async function bundleIssueReport2(report, description, title, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const timestamp = formatTimestamp2(options.now ?? new Date);
   const path = options.outputPath ?? join34(cwd, `magic-context-pi-issue-${timestamp}.md`);
-  mkdirSync10(dirname18(path), { recursive: true });
+  mkdirSync10(dirname19(path), { recursive: true });
   writeFileSync9(path, `${bodyMarkdown}
 `);
   const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join34(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
@@ -41680,11 +42566,11 @@ 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 existsSync40, 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";
+import { dirname as dirname20, isAbsolute as isAbsolute8, join as join35 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS5,
@@ -41775,7 +42661,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 {
@@ -41827,13 +42713,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) => existsSync40(join35(dir, "package.json")));
 }
 function projectConfigPath(cwd) {
   return resolveCortexKitProjectConfigPath(cwd);
 }
 function readConfigForEmbedding(path, isProjectConfig) {
-  if (!existsSync38(path))
+  if (!existsSync40(path))
     return null;
   try {
     const raw = loadRawConfigFile({
@@ -41934,7 +42820,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 || !existsSync40(path))
       return;
     let stat;
     try {
@@ -41945,9 +42831,9 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     if (!stat.isDirectory())
       return;
     const packageJson = join35(path, "package.json");
-    if (existsSync38(packageJson)) {
+    if (existsSync40(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) {
@@ -41962,7 +42848,7 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     }
     let entries = [];
     try {
-      entries = readdirSync7(path);
+      entries = readdirSync8(path);
     } catch {
       return;
     }
@@ -42012,7 +42898,7 @@ async function runHealthChecks2(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync38(settingsPath)) {
+  if (!existsSync40(settingsPath)) {
     add2(results, "fail", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -42036,7 +42922,7 @@ async function runHealthChecks2(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync38(path)) {
+    if (!existsSync40(path)) {
       if (required) {
         add2(results, "warn", `No ${label} magic-context.jsonc found at ${path}`);
         if (userConfigMigrationRefused) {
@@ -42078,7 +42964,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 = existsSync40(dbPath);
   if (existedBeforeOpen)
     add2(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -42296,7 +43182,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   return { results, repairPlan, ...summarize(results) };
 }
 function writeDefaultMagicContextConfig(path) {
-  mkdirSync11(dirname19(path), { recursive: true });
+  mkdirSync11(dirname20(path), { recursive: true });
   const config = {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
@@ -42318,7 +43204,7 @@ function repair2(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync38(configPath)) {
+    if (!existsSync40(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -42330,7 +43216,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) {
@@ -42565,12 +43451,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 existsSync41, rmSync as rmSync7 } from "node:fs";
 import { join as join36 } from "node:path";
 async function runDoctor4(options) {
   if (options.clear)
@@ -42668,9 +43554,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) {
@@ -42679,7 +43572,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) {
@@ -42702,8 +43595,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 (existsSync41(item.path)) {
+        rmSync7(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);
     } catch (err) {
@@ -42739,9 +43640,121 @@ var init_doctor = __esm(async () => {
 });
 
 // src/index.ts
-init_prompts();
 import { createRequire as createRequire9 } from "node:module";
 
+// src/lib/cli-help.ts
+var HELP_FLAGS = new Set(["--help", "-h"]);
+function hasHelpFlag(args) {
+  return args.some((arg) => HELP_FLAGS.has(arg));
+}
+var DOCTOR_SUBCOMMANDS_WITH_OWN_HELP = new Set([
+  "migrate",
+  "migrate-session",
+  "repair-db"
+]);
+var HARNESS_LINES = [
+  "  Harness selection:",
+  "    --harness opencode    Target OpenCode only",
+  "    --harness pi          Target Pi only",
+  "    --harness omp         Target Oh My Pi (OMP) only",
+  "    (default: auto-detect, prompt if multiple installed)"
+];
+var SETUP_HELP = [
+  "",
+  "  Usage: magic-context setup [--harness opencode|pi|omp] [--dry-run]",
+  "",
+  "  Interactive setup wizard: registers the Magic Context plugin with the",
+  "  selected harness and writes its Magic Context config.",
+  "",
+  "  Options:",
+  "    --dry-run             Preview the wizard without writing any files",
+  ...HARNESS_LINES,
+  ""
+].join(`
+`);
+var DOCTOR_HELP = [
+  "",
+  "  Usage: magic-context doctor [options]",
+  "         magic-context doctor <subcommand> [options]",
+  "",
+  "  Check the installed harnesses and fix configuration issues.",
+  "",
+  "  Options:",
+  "    --fix                               Repair safe, Magic Context-owned store rows and clear an outdated OpenCode 2 plugin cache",
+  "    --force                             Force-clear the plugin cache",
+  "    --clear                             Interactive cache cleanup picker",
+  "    --issue                             Collect diagnostics and open a GitHub issue",
+  "    --report <path>                     Write the issue diagnostics to <path> without prompting",
+  "    --check-v22-backfill                Show v22 memory backfill status",
+  "    --retry-v22-backfill                Retry failed v22 memory backfill rows",
+  "    --rekey-v22-dir-identity <path>     Re-key legacy dir identity rows",
+  ...HARNESS_LINES,
+  "",
+  "  Subcommands (each accepts --help):",
+  "    drain-authority <project>   Drain module memory/note authority back to TypeScript",
+  "    migrate                     Migrate an OpenCode session to Pi or OMP JSONL",
+  "    migrate-session             Re-home an OpenCode session to another directory",
+  "    merge-identity              Merge project rows between identities",
+  "    repair-db                   Back up and salvage a corrupted shared database",
+  "    list-hidden-sessions        List Magic Context OpenCode 2 roots",
+  ""
+].join(`
+`);
+var DRAIN_AUTHORITY_HELP = [
+  "",
+  "  Usage: magic-context doctor drain-authority <project>",
+  "",
+  "  Drain the module's memory and note authority for <project> back to TypeScript.",
+  ""
+].join(`
+`);
+var MERGE_IDENTITY_HELP = [
+  "",
+  "  Usage: magic-context doctor merge-identity --from <identity> --to <identity> [--dry-run] [--yes] [--db <path>]",
+  "",
+  "  Merge every project-scoped row from one project identity into another.",
+  "",
+  "  Options:",
+  "    --from <identity>   Identity whose rows are moved",
+  "    --to <identity>     Identity that receives them",
+  "    --dry-run           Report what would change without writing",
+  "    --yes               Confirm the write (required unless --dry-run)",
+  "    --db <path>         Use this context.db instead of the shared one",
+  ""
+].join(`
+`);
+var LIST_HIDDEN_SESSIONS_HELP = [
+  "",
+  "  Usage: magic-context doctor list-hidden-sessions",
+  "",
+  "  List the hidden OpenCode 2 root sessions Magic Context reuses for its",
+  "  historian and dreamer runs. Read-only.",
+  ""
+].join(`
+`);
+function subcommandHelp(argv) {
+  const [command, ...rest] = argv;
+  if (!hasHelpFlag(rest))
+    return null;
+  if (command === "setup")
+    return SETUP_HELP;
+  if (command !== "doctor")
+    return null;
+  const subcommand = rest[0];
+  if (subcommand === "drain-authority")
+    return DRAIN_AUTHORITY_HELP;
+  if (subcommand === "merge-identity")
+    return MERGE_IDENTITY_HELP;
+  if (subcommand === "list-hidden-sessions")
+    return LIST_HIDDEN_SESSIONS_HELP;
+  if (subcommand !== undefined && DOCTOR_SUBCOMMANDS_WITH_OWN_HELP.has(subcommand))
+    return null;
+  return DOCTOR_HELP;
+}
+
+// src/index.ts
+init_prompts();
+
 // src/lib/sqlite-preflight.ts
 async function probeSqliteBackend() {
   await init_sqlite().then(() => ({}));
@@ -42751,7 +43764,7 @@ function formatSqlitePreflightFailure(error) {
   return [
     "Magic Context doctor cannot use SQLite in this runtime.",
     `SQLite probe: ${detail}`,
-    "Remediation: install Node.js >= 24 or use a Bun build with node:sqlite.",
+    "Remediation: install Node.js 22.16+ (22.x) or >= 24, or use a Bun build with node:sqlite.",
     "For Docker, use node:24-slim or a two-runtime image."
   ].join(`
 `);
@@ -42818,6 +43831,7 @@ function printUsage() {
   console.log("    (default: auto-detect, prompt if multiple installed)");
   console.log("");
   console.log("  Usage:");
+  console.log("    npx @cortexkit/magic-context@latest <command> --help   # help for one command");
   console.log("    npx @cortexkit/magic-context@latest setup");
   console.log("        # add --dry-run to preview the wizard without writing any files");
   console.log("    npx @cortexkit/magic-context@latest doctor");
@@ -42837,6 +43851,11 @@ async function main(argv = process.argv.slice(2)) {
   }
   const command = argv[0];
   const rest = argv.slice(1);
+  const help = subcommandHelp(argv);
+  if (help !== null) {
+    console.log(help);
+    return 0;
+  }
   try {
     if (command === "setup") {
       await Promise.resolve().then(() => init_setup());