@cortexkit/magic-context 0.49.2 → 0.49.3

package/dist/index.js

@@ -13668,9 +13668,549 @@ var init_sqlite = __esm(async () => {
   indexCoordinationState = new Int32Array(indexCoordinationBuffer);
 });
 
+// src/lib/dashboard-install.ts
+import { execFile } from "node:child_process";
+import { createHash, createPublicKey, verify as cryptoVerify } from "node:crypto";
+import {
+  accessSync,
+  chmodSync as chmodSync3,
+  constants,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync3,
+  mkdtempSync,
+  readFileSync as readFileSync5,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  statSync as statSync5,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { homedir as homedir6, tmpdir as tmpdir2 } from "node:os";
+import { dirname as dirname6, join as join5 } from "node:path";
+import { promisify } from "node:util";
+import { gunzipSync } from "node:zlib";
+function resolveDashboardChoice(argv, interactive) {
+  if (argv.includes("--no-dashboard"))
+    return "skip-flag";
+  if (argv.includes("--dashboard"))
+    return "install";
+  return interactive ? "ask" : "skip-noninteractive";
+}
+function selectDashboardTarget(platform, arch) {
+  if (arch !== "x64" && arch !== "arm64")
+    return null;
+  switch (platform) {
+    case "darwin":
+      return {
+        platform: "macos",
+        assetName: `magic-context-dashboard-darwin-${arch}.app.tar.gz`
+      };
+    case "linux":
+      return {
+        platform: "linux",
+        assetName: `magic-context-dashboard-linux-${arch}.AppImage`
+      };
+    case "win32":
+      return {
+        platform: "windows",
+        assetName: `magic-context-dashboard-windows-${arch}.exe`
+      };
+    default:
+      return null;
+  }
+}
+function compareVersions(a, b) {
+  const parts = (value) => value.replace(/^v/, "").split(/[-+]/)[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left = parts(a);
+  const right = parts(b);
+  for (let i = 0;i < Math.max(left.length, right.length, 3); i++) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function formatSize(bytes) {
+  return `${(bytes / 1e6).toFixed(1)} MB`;
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    if (error.name === "TimeoutError")
+      return "the request timed out";
+    return error.message;
+  }
+  return String(error);
+}
+function verifyTauriSignature(data, signatureFile, publicKeyFile) {
+  const decodeLines = (value) => Buffer.from(value.trim(), "base64").toString("utf8").split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  const keyLine = decodeLines(publicKeyFile).find((line) => !line.startsWith("untrusted comment:"));
+  const key = Buffer.from(keyLine ?? "", "base64");
+  if (key.length !== 42 || key.subarray(0, 2).toString("latin1") !== "Ed") {
+    return { ok: false, reason: "the public key is malformed" };
+  }
+  const keyId = key.subarray(2, 10);
+  const publicKey = createPublicKey({
+    key: Buffer.concat([ED25519_SPKI_PREFIX, key.subarray(10)]),
+    format: "der",
+    type: "spki"
+  });
+  const lines = decodeLines(signatureFile);
+  const [untrusted, signatureLine, trustedLine, globalLine] = lines;
+  if (lines.length < 4 || !untrusted?.startsWith("untrusted comment:") || !trustedLine?.startsWith("trusted comment: ")) {
+    return { ok: false, reason: "the signature file is malformed" };
+  }
+  const signatureBlob = Buffer.from(signatureLine ?? "", "base64");
+  const algorithm = signatureBlob.subarray(0, 2).toString("latin1");
+  if (signatureBlob.length !== 74 || algorithm !== "ED" && algorithm !== "Ed") {
+    return { ok: false, reason: "the signature file is malformed" };
+  }
+  if (!signatureBlob.subarray(2, 10).equals(keyId)) {
+    return { ok: false, reason: "it was signed by a different key" };
+  }
+  const signature = signatureBlob.subarray(10);
+  const message = algorithm === "ED" ? createHash("blake2b512").update(data).digest() : Buffer.from(data);
+  if (!cryptoVerify(null, message, publicKey, signature)) {
+    return { ok: false, reason: "the signature does not match the file" };
+  }
+  const trustedComment = Buffer.from(trustedLine.slice("trusted comment: ".length), "utf8");
+  const globalSignature = Buffer.from(globalLine ?? "", "base64");
+  if (globalSignature.length !== 64 || !cryptoVerify(null, Buffer.concat([signature, trustedComment]), publicKey, globalSignature)) {
+    return { ok: false, reason: "the signature's trusted comment does not match" };
+  }
+  return { ok: true };
+}
+async function fetchLatestDashboardRelease(deps) {
+  const response = await deps.fetch(deps.releasesApiUrl, {
+    headers: { Accept: "application/vnd.github+json", "User-Agent": USER_AGENT },
+    signal: AbortSignal.timeout(deps.apiTimeoutMs)
+  });
+  if (!response.ok) {
+    throw new Error(`the GitHub releases API answered HTTP ${response.status}`);
+  }
+  const body = await response.json();
+  if (!Array.isArray(body))
+    throw new Error("the GitHub releases API returned an unexpected body");
+  let best = null;
+  for (const entry of body) {
+    if (entry.draft === true || entry.prerelease === true)
+      continue;
+    const tag = typeof entry.tag_name === "string" ? entry.tag_name : "";
+    const match = TAG_PATTERN.exec(tag);
+    if (!match?.[1])
+      continue;
+    const version = match[1];
+    if (best && compareVersions(version, best.version) <= 0)
+      continue;
+    const assets = [];
+    for (const asset of entry.assets ?? []) {
+      if (typeof asset.name !== "string" || typeof asset.browser_download_url !== "string") {
+        continue;
+      }
+      assets.push({
+        name: asset.name,
+        size: typeof asset.size === "number" ? asset.size : 0,
+        url: asset.browser_download_url
+      });
+    }
+    best = {
+      tag,
+      version,
+      htmlUrl: typeof entry.html_url === "string" ? entry.html_url : `${DASHBOARD_RELEASES_PAGE}/tag/${tag}`,
+      assets
+    };
+  }
+  if (!best)
+    throw new Error("no published dashboard-v* release was found");
+  return best;
+}
+async function download(deps, asset) {
+  const response = await deps.fetch(asset.url, {
+    headers: { "User-Agent": USER_AGENT },
+    redirect: "follow",
+    signal: AbortSignal.timeout(deps.downloadTimeoutMs)
+  });
+  if (!response.ok)
+    throw new Error(`downloading ${asset.name} failed with HTTP ${response.status}`);
+  return Buffer.from(await response.arrayBuffer());
+}
+function readMacAppVersion(appPath) {
+  try {
+    const plist = readFileSync5(join5(appPath, "Contents", "Info.plist"), "utf8");
+    const match = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/.exec(plist);
+    return match?.[1]?.trim() ?? null;
+  } catch {
+    return null;
+  }
+}
+function macApplicationDirs(deps) {
+  return [deps.macSystemApplicationsDir, join5(deps.homeDir, "Applications")];
+}
+function linuxVersionMarkerPath(homeDir) {
+  return join5(homeDir, ".local", "share", "cortexkit", "dashboard-appimage.json");
+}
+function linuxAppImagePath(homeDir) {
+  return join5(homeDir, ".local", "bin", DASHBOARD_APPIMAGE_NAME);
+}
+async function detectInstalledDashboard(target, deps) {
+  switch (target.platform) {
+    case "macos":
+      for (const dir of macApplicationDirs(deps)) {
+        const location = join5(dir, DASHBOARD_MAC_APP_NAME);
+        if (existsSync6(location))
+          return { location, version: readMacAppVersion(location) };
+      }
+      return null;
+    case "linux": {
+      const location = linuxAppImagePath(deps.homeDir);
+      if (existsSync6(location)) {
+        let version = null;
+        try {
+          const marker = JSON.parse(readFileSync5(linuxVersionMarkerPath(deps.homeDir), "utf8"));
+          if (typeof marker.version === "string")
+            version = marker.version;
+        } catch {
+          version = null;
+        }
+        return { location, version };
+      }
+      if (existsSync6(deps.linuxSystemBinaryPath)) {
+        return { location: deps.linuxSystemBinaryPath, version: null };
+      }
+      return null;
+    }
+    case "windows":
+      return deps.readWindowsInstall();
+  }
+}
+function isWritableDir(path) {
+  try {
+    if (!statSync5(path).isDirectory())
+      return false;
+    accessSync(path, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function unsafeArchivePath(path) {
+  if (path.startsWith("/") || path.startsWith("\\") || /^[A-Za-z]:/.test(path))
+    return true;
+  return path.split(/[/\\]/).some((segment) => segment === "..");
+}
+function tarString(block, start, length) {
+  const field = block.subarray(start, start + length);
+  const end = field.indexOf(0);
+  return field.subarray(0, end === -1 ? field.length : end).toString("utf8");
+}
+function tarSize(block) {
+  const field = block.subarray(124, 136);
+  if ((field[0] ?? 0) & 128) {
+    let value = (field[0] ?? 0) & 127;
+    for (const byte of field.subarray(1))
+      value = value * 256 + byte;
+    return value;
+  }
+  const text = tarString(block, 124, 12).trim();
+  return text === "" ? 0 : Number.parseInt(text, 8);
+}
+function paxRecords(data) {
+  const records = new Map;
+  let offset = 0;
+  while (offset < data.length) {
+    const space = data.indexOf(32, offset);
+    if (space === -1)
+      break;
+    const length = Number.parseInt(data.subarray(offset, space).toString("utf8"), 10);
+    if (!Number.isFinite(length) || length <= 0)
+      break;
+    const record = data.subarray(space + 1, offset + length - 1).toString("utf8");
+    const equals = record.indexOf("=");
+    if (equals !== -1)
+      records.set(record.slice(0, equals), record.slice(equals + 1));
+    offset += length;
+  }
+  return records;
+}
+function findUnsafeTarEntry(tar) {
+  const globalPax = new Map;
+  let nextPax = new Map;
+  let longName = null;
+  let longLink = null;
+  let offset = 0;
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0))
+      return null;
+    const size = tarSize(header);
+    if (!Number.isFinite(size) || size < 0)
+      return "an entry has an unreadable size";
+    const dataStart = offset + 512;
+    const data = tar.subarray(dataStart, dataStart + size);
+    offset = dataStart + Math.ceil(size / 512) * 512;
+    const type = String.fromCharCode(header[156] ?? 0);
+    if (type === "x" || type === "g") {
+      const records = paxRecords(data);
+      const target = type === "g" ? globalPax : nextPax;
+      for (const [key, value] of records)
+        target.set(key, value);
+      continue;
+    }
+    if (type === "L" || type === "K") {
+      const value = tarString(data, 0, data.length);
+      if (type === "L")
+        longName = value;
+      else
+        longLink = value;
+      continue;
+    }
+    const prefix = tarString(header, 345, 155);
+    const isUstar = header.subarray(257, 262).toString("latin1") === "ustar";
+    const headerName = tarString(header, 0, 100);
+    const name = nextPax.get("path") ?? longName ?? globalPax.get("path") ?? (isUstar && prefix ? `${prefix}/${headerName}` : headerName);
+    const link = nextPax.get("linkpath") ?? longLink ?? globalPax.get("linkpath") ?? tarString(header, 157, 100);
+    nextPax = new Map;
+    longName = null;
+    longLink = null;
+    if (unsafeArchivePath(name))
+      return `entry "${name}" points outside the archive`;
+    switch (type) {
+      case "0":
+      case "\x00":
+      case "7":
+      case "5":
+        break;
+      case "1":
+      case "2":
+        if (link === "" || unsafeArchivePath(link)) {
+          return `link "${name}" -> "${link}" points outside the archive`;
+        }
+        break;
+      default:
+        return `entry "${name}" has unsupported type "${type}"`;
+    }
+  }
+  return offset === tar.length ? null : "the archive is truncated";
+}
+async function installMac(data, deps, installed) {
+  let destinationDir;
+  if (installed) {
+    destinationDir = dirname6(installed.location);
+  } else if (isWritableDir(deps.macSystemApplicationsDir)) {
+    destinationDir = deps.macSystemApplicationsDir;
+  } else {
+    destinationDir = join5(deps.homeDir, "Applications");
+    deps.log.info(`${deps.macSystemApplicationsDir} is not writable, so the app goes to ${destinationDir} (setup never asks for sudo).`);
+  }
+  const unsafe = findUnsafeTarEntry(gunzipSync(data));
+  if (unsafe)
+    throw new Error(`the app archive is unsafe to extract: ${unsafe}`);
+  mkdirSync3(destinationDir, { recursive: true });
+  const staging = mkdtempSync(join5(destinationDir, ".magic-context-dashboard-"));
+  try {
+    const archive = join5(staging, "dashboard.app.tar.gz");
+    writeFileSync3(archive, data);
+    const extractDir = join5(staging, "extracted");
+    mkdirSync3(extractDir);
+    await deps.extractTarGz(archive, extractDir);
+    const extracted = join5(extractDir, DASHBOARD_MAC_APP_NAME);
+    if (!existsSync6(extracted)) {
+      throw new Error(`the archive did not contain ${DASHBOARD_MAC_APP_NAME}`);
+    }
+    const finalPath = join5(destinationDir, DASHBOARD_MAC_APP_NAME);
+    const previous = join5(staging, "previous.app");
+    const hadPrevious = existsSync6(finalPath);
+    if (hadPrevious)
+      renameSync3(finalPath, previous);
+    try {
+      renameSync3(extracted, finalPath);
+    } catch (error) {
+      if (hadPrevious)
+        renameSync3(previous, finalPath);
+      throw error;
+    }
+    return finalPath;
+  } finally {
+    rmSync3(staging, { recursive: true, force: true });
+  }
+}
+function installLinux(data, version, deps) {
+  const finalPath = linuxAppImagePath(deps.homeDir);
+  mkdirSync3(dirname6(finalPath), { recursive: true });
+  const partial = `${finalPath}.partial-${process.pid}`;
+  try {
+    writeFileSync3(partial, data, { mode: 493 });
+    chmodSync3(partial, 493);
+    renameSync3(partial, finalPath);
+  } finally {
+    rmSync3(partial, { force: true });
+  }
+  const marker = linuxVersionMarkerPath(deps.homeDir);
+  mkdirSync3(dirname6(marker), { recursive: true });
+  writeFileSync3(marker, `${JSON.stringify({ version, path: finalPath }, null, 2)}
+`);
+  return finalPath;
+}
+async function installWindows(data, asset, deps) {
+  const dir = mkdtempSync(join5(deps.tempRoot, "magic-context-dashboard-"));
+  try {
+    const installer = join5(dir, asset.name);
+    writeFileSync3(installer, data);
+    deps.log.info("Running the dashboard installer (per-user install, no administrator rights).");
+    await deps.runWindowsInstaller(installer);
+  } finally {
+    try {
+      rmSync3(dir, { recursive: true, force: true });
+    } catch {}
+  }
+  const installed = await deps.readWindowsInstall().catch(() => null);
+  return installed?.location ?? "the Start menu";
+}
+async function runOffer(argv, deps, state) {
+  const choice = resolveDashboardChoice(argv, deps.interactive);
+  if (choice === "skip-flag") {
+    deps.log.info("Skipping the Magic Context Dashboard (--no-dashboard).");
+    return;
+  }
+  if (choice === "skip-noninteractive") {
+    deps.log.info(`Skipped the Magic Context Dashboard offer (non-interactive run). Pass --dashboard to install it, or download it from ${DASHBOARD_RELEASES_PAGE}`);
+    return;
+  }
+  const target = selectDashboardTarget(deps.platform, deps.arch);
+  if (!target) {
+    deps.log.info(`No Magic Context Dashboard build exists for ${deps.platform}/${deps.arch}; see ${DASHBOARD_RELEASES_PAGE}`);
+    return;
+  }
+  const release = await fetchLatestDashboardRelease(deps);
+  state.link = release.htmlUrl;
+  const asset = release.assets.find((candidate) => candidate.name === target.assetName);
+  if (!asset)
+    throw new Error(`release ${release.tag} has no ${target.assetName}`);
+  const signatureAsset = release.assets.find((candidate) => candidate.name === `${target.assetName}.sig`);
+  if (!signatureAsset) {
+    throw new Error(`release ${release.tag} publishes no signature for ${target.assetName}, so it cannot be verified`);
+  }
+  const installed = await detectInstalledDashboard(target, deps);
+  const size = formatSize(asset.size);
+  let question;
+  if (installed) {
+    if (installed.version === null) {
+      deps.log.info(`Magic Context Dashboard is already installed at ${installed.location} (version unknown); it updates itself from inside the app.`);
+      return;
+    }
+    if (compareVersions(installed.version, release.version) >= 0) {
+      deps.log.info(`Magic Context Dashboard v${installed.version} is already installed at ${installed.location} (latest release: v${release.version}).`);
+      return;
+    }
+    deps.log.info(`Magic Context Dashboard v${installed.version} is installed at ${installed.location}; v${release.version} is available.`);
+    question = `Update the Magic Context Dashboard to v${release.version}? (${size} download)`;
+  } else {
+    question = `Install the Magic Context Dashboard (desktop app for memories, sessions and settings)? v${release.version}, ${size} download`;
+  }
+  if (choice === "ask" && !await deps.confirm(question, true)) {
+    deps.log.info(`Skipped the Magic Context Dashboard. It is available at ${release.htmlUrl}`);
+    return;
+  }
+  deps.log.step(`Downloading ${asset.name} (${size})…`);
+  const [data, signature] = await Promise.all([
+    download(deps, asset),
+    download(deps, signatureAsset)
+  ]);
+  const verdict = verifyTauriSignature(data, signature.toString("utf8"), deps.publicKey);
+  if (!verdict.ok) {
+    throw new Error(`${asset.name} failed signature verification (${verdict.reason}); nothing was installed`);
+  }
+  deps.log.info(`Verified ${asset.name} against the dashboard's updater signing key.`);
+  let location;
+  switch (target.platform) {
+    case "macos":
+      location = await installMac(data, deps, installed);
+      break;
+    case "linux":
+      deps.log.info("Installing the AppImage to ~/.local/bin: it needs no root, runs on any distribution, and is what the app's own updater replaces (the .deb/.rpm packages would need sudo).");
+      location = installLinux(data, release.version, deps);
+      break;
+    case "windows":
+      location = await installWindows(data, asset, deps);
+      break;
+  }
+  deps.log.success(`Installed Magic Context Dashboard v${release.version} → ${location}`);
+}
+function isInteractiveTerminal(stdinIsTTY, stdoutIsTTY, env) {
+  const ci = env.CI?.trim().toLowerCase();
+  const isCi = ci !== undefined && ci !== "" && ci !== "0" && ci !== "false";
+  return Boolean(stdinIsTTY && stdoutIsTTY) && !isCi;
+}
+async function readWindowsInstallFromRegistry() {
+  for (const hive of ["HKCU", "HKLM"]) {
+    const key = `${hive}\\${WINDOWS_UNINSTALL_KEY}`;
+    try {
+      const { stdout } = await execFileAsync("reg", ["query", key], { windowsHide: true });
+      const values = new Map;
+      for (const line of stdout.split(/\r?\n/)) {
+        const match = /^\s+(\S+)\s+REG_\w+\s+(.*)$/.exec(line);
+        if (match?.[1] && match[2] !== undefined)
+          values.set(match[1], match[2].trim());
+      }
+      return {
+        location: values.get("InstallLocation") || key,
+        version: values.get("DisplayVersion") || null
+      };
+    } catch {}
+  }
+  return null;
+}
+function defaultDashboardInstallDeps() {
+  return {
+    log: log3,
+    confirm: (message, defaultYes) => confirm2(message, defaultYes),
+    interactive: isInteractiveTerminal(process.stdin.isTTY, process.stdout.isTTY, process.env),
+    platform: process.platform,
+    arch: process.arch,
+    homeDir: homedir6(),
+    fetch: globalThis.fetch,
+    releasesApiUrl: DASHBOARD_RELEASES_API,
+    publicKey: DASHBOARD_UPDATER_PUBLIC_KEY,
+    apiTimeoutMs: 15000,
+    downloadTimeoutMs: 10 * 60000,
+    macSystemApplicationsDir: "/Applications",
+    linuxSystemBinaryPath: "/usr/bin/magic-context-dashboard",
+    tempRoot: tmpdir2(),
+    extractTarGz: async (archive, destinationDir) => {
+      await execFileAsync("tar", ["-xzf", archive, "-C", destinationDir], {
+        windowsHide: true
+      });
+    },
+    runWindowsInstaller: async (installerPath) => {
+      await execFileAsync(installerPath, ["/P"], { windowsHide: false });
+    },
+    readWindowsInstall: readWindowsInstallFromRegistry
+  };
+}
+async function offerDashboardInstall(argv, overrides = {}) {
+  const deps = { ...defaultDashboardInstallDeps(), ...overrides };
+  const state = { link: DASHBOARD_RELEASES_PAGE };
+  try {
+    await runOffer(argv, deps, state);
+  } catch (error) {
+    if (isPromptCancelledError(error)) {
+      deps.log.info("Skipped the Magic Context Dashboard.");
+      return;
+    }
+    deps.log.warn(`Magic Context Dashboard was not installed: ${errorMessage(error)}. Install it manually from ${state.link}`);
+  }
+}
+var execFileAsync, DASHBOARD_RELEASES_PAGE = "https://github.com/cortexkit/magic-context/releases", DASHBOARD_RELEASES_API = "https://api.github.com/repos/cortexkit/magic-context/releases?per_page=100", DASHBOARD_UPDATER_PUBLIC_KEY = "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDY5MUNBMDIxNjUxMEM2MkYKUldRdnhoQmxJYUFjYVU0SlNNbzRWMGJ3MndKOENIVDR0N0N6b0Jyd1l6TUNFTlpZTzV3RXlRYkEK", DASHBOARD_PRODUCT_NAME = "Magic Context Dashboard", DASHBOARD_MAC_APP_NAME, DASHBOARD_APPIMAGE_NAME = "magic-context-dashboard.AppImage", USER_AGENT = "magic-context-setup", TAG_PATTERN, ED25519_SPKI_PREFIX, WINDOWS_UNINSTALL_KEY;
+var init_dashboard_install = __esm(() => {
+  init_prompts();
+  execFileAsync = promisify(execFile);
+  DASHBOARD_MAC_APP_NAME = `${DASHBOARD_PRODUCT_NAME}.app`;
+  TAG_PATTERN = /^dashboard-v(\d+\.\d+\.\d+)$/;
+  ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+  WINDOWS_UNINSTALL_KEY = `Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\${DASHBOARD_PRODUCT_NAME}`;
+});
+
 // src/lib/docs-proposal-gitignore.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
-import { join as join5 } from "node:path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync7, readFileSync as readFileSync6 } from "node:fs";
+import { join as join6 } from "node:path";
 function coversProposalState(line) {
   const rule = line.trim();
   if (rule === "" || rule.startsWith("#") || rule.startsWith("!"))
@@ -13679,16 +14219,16 @@ function coversProposalState(line) {
   return COVERING_PATHS.has(normalized);
 }
 function ensureDocsProposalGitignore(projectDir) {
-  if (!existsSync6(join5(projectDir, ".git")))
+  if (!existsSync7(join6(projectDir, ".git")))
     return { status: "not-a-repository" };
-  const path = join5(projectDir, ".gitignore");
+  const path = join6(projectDir, ".gitignore");
   try {
-    const text = existsSync6(path) ? readFileSync5(path, "utf8") : "";
+    const text = existsSync7(path) ? readFileSync6(path, "utf8") : "";
     if (text.split(/\r?\n/).some(coversProposalState))
       return { status: "covered" };
-    const nestedPath = join5(projectDir, ".cortexkit", ".gitignore");
-    if (existsSync6(nestedPath)) {
-      const nested = readFileSync5(nestedPath, "utf8").split(/\r?\n/);
+    const nestedPath = join6(projectDir, ".cortexkit", ".gitignore");
+    if (existsSync7(nestedPath)) {
+      const nested = readFileSync6(nestedPath, "utf8").split(/\r?\n/);
       if (nested.some((line) => /^\/?magic-context(\/(\*\*?)?)?$/.test(line.trim()))) {
         return { status: "covered" };
       }
@@ -13712,8 +14252,8 @@ var init_docs_proposal_gitignore = __esm(() => {
 });
 
 // src/lib/find-on-path.ts
-import { accessSync, constants, existsSync as existsSync7, statSync as statSync5 } from "node:fs";
-import { delimiter, join as join6 } from "node:path";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync8, statSync as statSync6 } from "node:fs";
+import { delimiter, join as join7 } from "node:path";
 function findOnPath(binary) {
   const PATH = process.env.PATH;
   if (typeof PATH !== "string" || PATH.length === 0)
@@ -13725,7 +14265,7 @@ function findOnPath(binary) {
     if (!dir)
       continue;
     for (const candidate of candidates) {
-      const fullPath = join6(dir, candidate);
+      const fullPath = join7(dir, candidate);
       if (isExecutableFile(fullPath, isWindows))
         return fullPath;
     }
@@ -13734,15 +14274,15 @@ function findOnPath(binary) {
 }
 function isExecutableFile(path, isWindows = process.platform === "win32") {
   try {
-    if (!existsSync7(path))
+    if (!existsSync8(path))
       return false;
-    const st = statSync5(path);
+    const st = statSync6(path);
     if (!st.isFile())
       return false;
     if (isWindows) {
       return true;
     }
-    accessSync(path, constants.X_OK);
+    accessSync2(path, constants2.X_OK);
     return true;
   } catch {
     return false;
@@ -13751,28 +14291,28 @@ function isExecutableFile(path, isWindows = process.platform === "win32") {
 var init_find_on_path = () => {};
 
 // src/lib/paths.ts
-import { existsSync as existsSync8, readdirSync as readdirSync2, statSync as statSync6 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { delimiter as delimiter2, dirname as dirname6, join as join7, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync2, statSync as statSync7 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { delimiter as delimiter2, dirname as dirname7, join as join8, resolve as resolve3 } from "node:path";
 function getOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
     return envDir;
   if (process.platform === "win32") {
-    return join7(homedir6(), ".config", "opencode");
+    return join8(homedir7(), ".config", "opencode");
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join7(homedir6(), ".config");
-  return join7(xdgConfig, "opencode");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join8(homedir7(), ".config");
+  return join8(xdgConfig, "opencode");
 }
 function findOmoConfig(configDir) {
   const locations = [
-    join7(configDir, "oh-my-openagent.jsonc"),
-    join7(configDir, "oh-my-openagent.json"),
-    join7(configDir, "oh-my-opencode.jsonc"),
-    join7(configDir, "oh-my-opencode.json")
+    join8(configDir, "oh-my-openagent.jsonc"),
+    join8(configDir, "oh-my-openagent.json"),
+    join8(configDir, "oh-my-opencode.jsonc"),
+    join8(configDir, "oh-my-opencode.json")
   ];
   for (const loc of locations) {
-    if (existsSync8(loc))
+    if (existsSync9(loc))
       return loc;
   }
   return null;
@@ -13783,24 +14323,24 @@ function detectConfigPaths() {
   let opencodeConfigFormat;
   let tuiConfig;
   let tuiConfigFormat;
-  const jsoncPath = join7(configDir, "opencode.jsonc");
-  const jsonPath = join7(configDir, "opencode.json");
-  if (existsSync8(jsoncPath)) {
+  const jsoncPath = join8(configDir, "opencode.jsonc");
+  const jsonPath = join8(configDir, "opencode.json");
+  if (existsSync9(jsoncPath)) {
     opencodeConfig = jsoncPath;
     opencodeConfigFormat = "jsonc";
-  } else if (existsSync8(jsonPath)) {
+  } else if (existsSync9(jsonPath)) {
     opencodeConfig = jsonPath;
     opencodeConfigFormat = "json";
   } else {
     opencodeConfig = jsoncPath;
     opencodeConfigFormat = "none";
   }
-  const tuiJsoncPath = join7(configDir, "tui.jsonc");
-  const tuiJsonPath = join7(configDir, "tui.json");
-  if (existsSync8(tuiJsoncPath)) {
+  const tuiJsoncPath = join8(configDir, "tui.jsonc");
+  const tuiJsonPath = join8(configDir, "tui.json");
+  if (existsSync9(tuiJsoncPath)) {
     tuiConfig = tuiJsoncPath;
     tuiConfigFormat = "jsonc";
-  } else if (existsSync8(tuiJsonPath)) {
+  } else if (existsSync9(tuiJsonPath)) {
     tuiConfig = tuiJsonPath;
     tuiConfigFormat = "json";
   } else {
@@ -13819,37 +14359,37 @@ function detectConfigPaths() {
 }
 function envFirstHomeDir() {
   const home = process.env.HOME?.trim();
-  return home || homedir6();
+  return home || homedir7();
 }
 function getPiAgentDir() {
   const envDir = process.env.PI_CODING_AGENT_DIR?.trim();
   if (envDir)
     return envDir;
-  return join7(envFirstHomeDir(), ".pi", "agent");
+  return join8(envFirstHomeDir(), ".pi", "agent");
 }
 function getPiAgentConfigDir() {
   return getPiAgentDir();
 }
 function getPiSessionsRoot() {
-  return join7(getPiAgentDir(), "sessions");
+  return join8(getPiAgentDir(), "sessions");
 }
 function getPiCacheRoot() {
-  return join7(dirname6(getPiAgentDir()), "cache");
+  return join8(dirname7(getPiAgentDir()), "cache");
 }
 function getPiUserConfigPath() {
   return resolveCortexKitUserConfigPath();
 }
 function getPiUserExtensionsPath() {
-  return join7(getPiAgentConfigDir(), "settings.json");
+  return join8(getPiAgentConfigDir(), "settings.json");
 }
 function resolveOmpPaths() {
   const rawProfile = process.env.OMP_PROFILE ?? process.env.PI_PROFILE;
   const normalizedProfile = rawProfile?.trim();
   const profile = normalizedProfile && normalizedProfile !== "default" && /^[a-z0-9][a-z0-9._-]{0,63}$/.test(normalizedProfile) ? normalizedProfile : undefined;
   const configDirName = process.env.PI_CONFIG_DIR?.trim() || ".omp";
-  const baseConfigRoot = join7(envFirstHomeDir(), configDirName);
-  const configRoot = profile ? join7(baseConfigRoot, "profiles", profile) : baseConfigRoot;
-  const defaultAgentDir = join7(configRoot, "agent");
+  const baseConfigRoot = join8(envFirstHomeDir(), configDirName);
+  const configRoot = profile ? join8(baseConfigRoot, "profiles", profile) : baseConfigRoot;
+  const defaultAgentDir = join8(configRoot, "agent");
   const override = profile ? undefined : process.env.PI_CODING_AGENT_DIR?.trim();
   const agentDir = override ? resolve3(override) : defaultAgentDir;
   const canUseXdg = (process.platform === "linux" || process.platform === "darwin") && agentDir === defaultAgentDir;
@@ -13857,9 +14397,9 @@ function resolveOmpPaths() {
   if (canUseXdg) {
     const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
     if (xdgDataHome) {
-      const appRoot = join7(xdgDataHome, "omp");
-      const candidate = profile ? join7(appRoot, "profiles", profile) : appRoot;
-      if (existsSync8(candidate))
+      const appRoot = join8(xdgDataHome, "omp");
+      const candidate = profile ? join8(appRoot, "profiles", profile) : appRoot;
+      if (existsSync9(candidate))
         dataRoot = candidate;
     }
   }
@@ -13869,8 +14409,8 @@ function resolveOmpPaths() {
     agentDir,
     dataRoot,
     dataAgentRoot,
-    pluginsDir: join7(dataRoot, "plugins"),
-    sessionsRoot: join7(dataAgentRoot, "sessions")
+    pluginsDir: join8(dataRoot, "plugins"),
+    sessionsRoot: join8(dataAgentRoot, "sessions")
   };
 }
 function getOmpAgentDir() {
@@ -13880,7 +14420,7 @@ function getOmpSessionsRoot() {
   return resolveOmpPaths().sessionsRoot;
 }
 function getOmpConfigPath() {
-  return join7(resolveOmpPaths().agentDir, "config.yml");
+  return join8(resolveOmpPaths().agentDir, "config.yml");
 }
 function getOmpPackageDir() {
   const value = process.env.PI_PACKAGE_DIR?.trim();
@@ -13897,11 +14437,11 @@ function getOmpNonGlobalConfigSources(cwd = process.cwd()) {
   const sources = process.env.PI_CONFIG_FILES?.split(delimiter2).map((entry) => entry.trim()).filter(Boolean).map((entry) => {
     if (entry === "~")
       return envFirstHomeDir();
-    const expanded = entry.startsWith("~/") || entry.startsWith("~\\") ? join7(envFirstHomeDir(), entry.slice(2)) : entry;
+    const expanded = entry.startsWith("~/") || entry.startsWith("~\\") ? join8(envFirstHomeDir(), entry.slice(2)) : entry;
     return resolve3(cwd, expanded);
   }) ?? [];
   const projectConfig = resolve3(cwd, ".omp", "config.yml");
-  if (existsSync8(projectConfig))
+  if (existsSync9(projectConfig))
     sources.push(projectConfig);
   return [...new Set(sources)];
 }
@@ -13909,7 +14449,7 @@ function getOmpPluginsDir() {
   return resolveOmpPaths().pluginsDir;
 }
 function getOmpPluginsLockPath() {
-  return join7(resolveOmpPaths().pluginsDir, "omp-plugins.lock.json");
+  return join8(resolveOmpPaths().pluginsDir, "omp-plugins.lock.json");
 }
 function getOmpUserConfigPath() {
   return resolveCortexKitUserConfigPath();
@@ -13921,16 +14461,16 @@ function getMagicContextHistorianDir2(harness) {
   return getMagicContextHistorianDir(harness);
 }
 function getOpenCodePluginCacheDir() {
-  const xdg = process.env.XDG_CACHE_HOME || join7(homedir6(), ".cache");
-  return join7(xdg, "opencode", "packages");
+  const xdg = process.env.XDG_CACHE_HOME || join8(homedir7(), ".cache");
+  return join8(xdg, "opencode", "packages");
 }
 function getOpenCodeV2NpmCacheDir() {
-  const xdg = process.env.XDG_CACHE_HOME || join7(homedir6(), ".cache");
-  return join7(xdg, "opencode", "npm");
+  const xdg = process.env.XDG_CACHE_HOME || join8(homedir7(), ".cache");
+  return join8(xdg, "opencode", "npm");
 }
 function isDir(path) {
   try {
-    return statSync6(path).isDirectory();
+    return statSync7(path).isDirectory();
   } catch {
     return false;
   }
@@ -13947,12 +14487,12 @@ function dirSizeBytes(path) {
     try {
       const entries = readdirSync2(cur, { withFileTypes: true });
       for (const entry of entries) {
-        const child = join7(cur, entry.name);
+        const child = join8(cur, entry.name);
         if (entry.isDirectory()) {
           stack.push(child);
         } else if (entry.isFile()) {
           try {
-            total += statSync6(child).size;
+            total += statSync7(child).size;
           } catch {}
         }
       }
@@ -13967,8 +14507,8 @@ var init_paths = __esm(() => {
 
 // src/lib/pi-helpers.ts
 import { execFileSync, spawnSync } from "node:child_process";
-import { homedir as homedir7 } from "node:os";
-import { extname, join as join8 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { extname, join as join9 } from "node:path";
 function getPiCommandInvocation(piPath, args) {
   const extension = extname(piPath).toLowerCase();
   if (extension !== ".cmd" && extension !== ".bat") {
@@ -13981,8 +14521,8 @@ function detectPiBinary() {
   const fromPath = findOnPath("pi");
   if (fromPath)
     return { path: fromPath, source: "path" };
-  const home = process.env.HOME?.trim() || homedir7();
-  const homeCandidate = process.platform === "win32" ? join8(home, ".pi", "bin", "pi.cmd") : join8(home, ".pi", "bin", "pi");
+  const home = process.env.HOME?.trim() || homedir8();
+  const homeCandidate = process.platform === "win32" ? join9(home, ".pi", "bin", "pi.cmd") : join9(home, ".pi", "bin", "pi");
   if (isExecutableFile(homeCandidate))
     return { path: homeCandidate, source: "home" };
   return null;
@@ -14071,9 +14611,9 @@ var init_pi_helpers = __esm(() => {
 
 // src/lib/omp-helpers.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { extname as extname2, join as join9 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { extname as extname2, join as join10 } from "node:path";
 function detectOmpPackageCli() {
   const packageDir = getOmpPackageDir();
   if (!packageDir)
@@ -14081,11 +14621,11 @@ function detectOmpPackageCli() {
   if (!findOnPath("bun"))
     return null;
   try {
-    const manifest = JSON.parse(readFileSync6(join9(packageDir, "package.json"), "utf-8"));
+    const manifest = JSON.parse(readFileSync7(join10(packageDir, "package.json"), "utf-8"));
     if (manifest.name !== "@oh-my-pi/pi-coding-agent")
       return null;
-    const cli = join9(packageDir, "dist", "cli.js");
-    return existsSync9(cli) ? cli : null;
+    const cli = join10(packageDir, "dist", "cli.js");
+    return existsSync10(cli) ? cli : null;
   } catch {
     return null;
   }
@@ -14100,13 +14640,13 @@ function getOmpCommandInvocation(ompPath, args) {
 }
 function getOmpFallbackCandidates(platform, home, appData) {
   if (platform !== "win32") {
-    return [join9(home, ".bun", "bin", "omp"), join9(home, ".local", "bin", "omp")];
+    return [join10(home, ".bun", "bin", "omp"), join10(home, ".local", "bin", "omp")];
   }
   const npmRoot = appData?.trim();
   return [
-    ...npmRoot ? [join9(npmRoot, "npm", "omp.cmd"), join9(npmRoot, "npm", "omp.exe")] : [],
-    join9(home, ".bun", "bin", "omp.exe"),
-    join9(home, ".bun", "bin", "omp.cmd")
+    ...npmRoot ? [join10(npmRoot, "npm", "omp.cmd"), join10(npmRoot, "npm", "omp.exe")] : [],
+    join10(home, ".bun", "bin", "omp.exe"),
+    join10(home, ".bun", "bin", "omp.cmd")
   ];
 }
 function detectOmpBinary() {
@@ -14116,7 +14656,7 @@ function detectOmpBinary() {
   const fromPackage = detectOmpPackageCli();
   if (fromPackage)
     return { path: fromPackage, source: "package" };
-  const home = process.env.HOME?.trim() || homedir8();
+  const home = process.env.HOME?.trim() || homedir9();
   const candidates = getOmpFallbackCandidates(process.platform, home, process.env.APPDATA);
   const candidate = candidates.find((path) => isExecutableFile(path));
   return candidate ? { path: candidate, source: "home" } : null;
@@ -14229,8 +14769,8 @@ var init_omp_helpers = __esm(() => {
 });
 
 // src/adapters/omp.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "node:fs";
+import { join as join11 } from "node:path";
 
 class OmpAdapter {
   kind = "omp";
@@ -14330,8 +14870,8 @@ class OmpAdapter {
     return "Install OMP: https://omp.sh (npm: @oh-my-pi/pi-coding-agent)";
   }
   getPluginCacheInfo() {
-    const path = join10(getOmpPluginsDir(), "cache");
-    return [{ path, exists: existsSync10(path), sizeBytes: dirSizeBytes(path) }];
+    const path = join11(getOmpPluginsDir(), "cache");
+    return [{ path, exists: existsSync11(path), sizeBytes: dirSizeBytes(path) }];
   }
   getLogPath() {
     return getMagicContextLogPath2("omp");
@@ -14344,7 +14884,7 @@ class OmpAdapter {
   }
   readRuntimeEnabled(configPath) {
     try {
-      const lock = JSON.parse(readFileSync7(configPath, "utf-8"));
+      const lock = JSON.parse(readFileSync8(configPath, "utf-8"));
       const enabled = lock.plugins?.[OMP_PLUGIN_PACKAGE]?.enabled;
       return typeof enabled === "boolean" ? enabled : undefined;
     } catch {
@@ -14372,9 +14912,9 @@ var init_omp = __esm(() => {
 });
 
 // ../plugin/src/shared/opencode-db-path.ts
-import { existsSync as existsSync11, readdirSync as readdirSync3, statSync as statSync7 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { isAbsolute as isAbsolute4, join as join11, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync3, statSync as statSync8 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { isAbsolute as isAbsolute4, join as join12, resolve as resolve4 } from "node:path";
 function openCodeHostGenerationFromVersion(version) {
   const text = version ?? "";
   if (/(?:^|\s|v)0\.0\.0-(?:beta|dev)-/.test(text))
@@ -14383,7 +14923,7 @@ function openCodeHostGenerationFromVersion(version) {
   return Number.isFinite(major) && major >= 2 ? "v2" : "v1";
 }
 function openCodeDataDir(env = process.env, dataHome) {
-  return join11(dataHome ?? env.XDG_DATA_HOME ?? join11(homedir9(), ".local", "share"), "opencode");
+  return join12(dataHome ?? env.XDG_DATA_HOME ?? join12(homedir10(), ".local", "share"), "opencode");
 }
 function environmentKey(dataDir, hostGeneration, channel, env) {
   return [
@@ -14395,7 +14935,7 @@ function environmentKey(dataDir, hostGeneration, channel, env) {
   ].join("\x00");
 }
 function channelPath(dataDir, channel) {
-  return ["latest", "beta", "prod"].includes(channel) ? join11(dataDir, "opencode.db") : join11(dataDir, `opencode-${channel}.db`);
+  return ["latest", "beta", "prod"].includes(channel) ? join12(dataDir, "opencode.db") : join12(dataDir, `opencode-${channel}.db`);
 }
 function discoveredCandidateNames(dataDir) {
   const names = ["opencode.db", "opencode-local.db", "opencode-dev.db"];
@@ -14407,9 +14947,9 @@ function discoveredCandidateNames(dataDir) {
 }
 function discoverOpenCodeDb(dataDir) {
   const candidates = discoveredCandidateNames(dataDir).map((name, order) => {
-    const path = join11(dataDir, name);
+    const path = join12(dataDir, name);
     try {
-      const metadata = statSync7(path);
+      const metadata = statSync8(path);
       return metadata.isFile() ? { path, order, mtimeMs: metadata.mtimeMs } : null;
     } catch {
       return null;
@@ -14417,7 +14957,7 @@ function discoverOpenCodeDb(dataDir) {
   });
   const existing = candidates.filter((candidate) => candidate !== null).sort((left, right) => right.mtimeMs - left.mtimeMs || left.order - right.order)[0];
   if (!existing) {
-    return { path: join11(dataDir, "opencode.db"), source: "default", channel: null };
+    return { path: join12(dataDir, "opencode.db"), source: "default", channel: null };
   }
   const name = existing.path.slice(dataDir.length + 1);
   const channel = name === "opencode.db" ? null : name.slice("opencode-".length, -".db".length) || null;
@@ -14430,14 +14970,14 @@ function resolveV1Fresh(dataDir, env = process.env) {
       return { path: explicit, source: "OPENCODE_DB", channel: null };
     }
     return {
-      path: isAbsolute4(explicit) ? explicit : join11(dataDir, explicit),
+      path: isAbsolute4(explicit) ? explicit : join12(dataDir, explicit),
       source: "OPENCODE_DB",
       channel: null
     };
   }
   const disableChannelDb = env.OPENCODE_DISABLE_CHANNEL_DB;
   if (disableChannelDb === "1" || disableChannelDb === "true") {
-    return { path: join11(dataDir, "opencode.db"), source: "default", channel: null };
+    return { path: join12(dataDir, "opencode.db"), source: "default", channel: null };
   }
   const channel = env.OPENCODE_CHANNEL;
   if (channel !== undefined && channel.length > 0) {
@@ -14471,7 +15011,7 @@ function resolveOpenCodeDbPath(hostGeneration = "v1", options = {}) {
   const dataDir = openCodeDataDir(env, options.dataHome);
   const channel = options.channel ?? env.OPENCODE_CHANNEL;
   const key = environmentKey(dataDir, hostGeneration, channel, env);
-  if (cachedResolution?.key === key && (!cachedResolution.existed || existsSync11(cachedResolution.resolution.path))) {
+  if (cachedResolution?.key === key && (!cachedResolution.existed || existsSync12(cachedResolution.resolution.path))) {
     if (cachedResolution.existed)
       return cachedResolution.resolution;
   }
@@ -14479,7 +15019,7 @@ function resolveOpenCodeDbPath(hostGeneration = "v1", options = {}) {
   cachedResolution = {
     key,
     resolution,
-    existed: resolution.path !== ":memory:" && existsSync11(resolution.path)
+    existed: resolution.path !== ":memory:" && existsSync12(resolution.path)
   };
   return resolution;
 }
@@ -14519,7 +15059,7 @@ function assertOpenCodeStoreGeneration(db, expected, path, schema = "main") {
   throw new Error(`OpenCode store generation mismatch at ${path}: expected ${expected}, found ${actual}; refusing generation-specific database access`);
 }
 function openCodeDbPathExists(resolution = resolveOpenCodeDbPath()) {
-  return resolution.path !== ":memory:" && existsSync11(resolution.path);
+  return resolution.path !== ":memory:" && existsSync12(resolution.path);
 }
 function getOpenCodeDbProbeDescriptions(resolution = resolveOpenCodeDbPath()) {
   if (resolution.source === "OPENCODE_DB")
@@ -14529,10 +15069,10 @@ function getOpenCodeDbProbeDescriptions(resolution = resolveOpenCodeDbPath()) {
   }
   const dataDir = openCodeDataDir();
   return [
-    join11(dataDir, "opencode.db"),
-    join11(dataDir, "opencode-local.db"),
-    join11(dataDir, "opencode-dev.db"),
-    join11(dataDir, "opencode-<channel>.db")
+    join12(dataDir, "opencode.db"),
+    join12(dataDir, "opencode-local.db"),
+    join12(dataDir, "opencode-dev.db"),
+    join12(dataDir, "opencode-<channel>.db")
   ];
 }
 function lookedForText(resolution) {
@@ -22437,8 +22977,8 @@ function projectDirectoryKey(directory) {
 var init_project_directory_key = () => {};
 
 // ../plugin/src/shared/rpc-utils.ts
-import { execFile, execFileSync as execFileSync2 } from "node:child_process";
-import { readFileSync as readFileSync8 } from "node:fs";
+import { execFile as execFile2, execFileSync as execFileSync2 } from "node:child_process";
+import { readFileSync as readFileSync9 } from "node:fs";
 function isOwnRpcServerRecord(record) {
   return record.pid === process.pid && record.instance_id !== undefined && ownRpcServerInstanceIds.has(record.instance_id);
 }
@@ -23033,7 +23573,7 @@ var init_rpc_utils = __esm(() => {
     "cljs/dist",
     "dist/bundle/cli"
   ];
-  rpcIdentityReadFileSync = readFileSync8;
+  rpcIdentityReadFileSync = readFileSync9;
   rpcIdentityExecFileSync = execFileSync2;
   rpcIdentityProcessKill = process.kill;
   rpcProcessListExecFileSync = execFileSync2;
@@ -23074,23 +23614,23 @@ var init_opencode_plugin_registration = __esm(() => {
 });
 
 // src/lib/opencode-plugin-cache.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
-import { join as join12 } from "node:path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync10 } from "node:fs";
+import { join as join13 } from "node:path";
 function getOpenCodePluginCacheRoots() {
   const cacheDir = getOpenCodePluginCacheDir();
   return [
-    join12(cacheDir, OPENCODE_PLUGIN_ENTRY_WITH_VERSION),
-    join12(cacheDir, OPENCODE_PLUGIN_NAME)
+    join13(cacheDir, OPENCODE_PLUGIN_ENTRY_WITH_VERSION),
+    join13(cacheDir, OPENCODE_PLUGIN_NAME)
   ];
 }
 function getOpenCodePluginPackageJsonPath(pluginCacheRoot) {
-  return join12(pluginCacheRoot, "node_modules", ...OPENCODE_PLUGIN_NAME.split("/"), "package.json");
+  return join13(pluginCacheRoot, "node_modules", ...OPENCODE_PLUGIN_NAME.split("/"), "package.json");
 }
 function getOpenCodePluginPackageJsonPaths() {
   return getOpenCodePluginCacheRoots().map(getOpenCodePluginPackageJsonPath);
 }
 function getOpenCodeV2PluginCacheSlot(npmCacheDir = getOpenCodeV2NpmCacheDir(), spec = "latest") {
-  return join12(npmCacheDir, ...`${OPENCODE_PLUGIN_NAME}@${spec}`.split("/"));
+  return join13(npmCacheDir, ...`${OPENCODE_PLUGIN_NAME}@${spec}`.split("/"));
 }
 function openCodeV2PluginSpecOf(specifier) {
   if (specifier === OPENCODE_PLUGIN_NAME)
@@ -23143,7 +23683,7 @@ function pluginEntrySpecifier(entry) {
 }
 function listOpenCodeV2PluginCacheSlots(npmCacheDir = getOpenCodeV2NpmCacheDir()) {
   const [scope = "", name = ""] = OPENCODE_PLUGIN_NAME.split("/");
-  const scopeDir = join12(npmCacheDir, scope);
+  const scopeDir = join13(npmCacheDir, scope);
   let names;
   try {
     names = readdirSync4(scopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith(`${name}@`)).map((entry) => entry.name);
@@ -23151,7 +23691,7 @@ function listOpenCodeV2PluginCacheSlots(npmCacheDir = getOpenCodeV2NpmCacheDir()
     return [];
   }
   return names.map((dirName) => {
-    const slot = join12(scopeDir, dirName);
+    const slot = join13(scopeDir, dirName);
     return {
       spec: dirName.slice(name.length + 1),
       slot,
@@ -23167,7 +23707,7 @@ function getOpenCodeV2ActiveGeneration(slot) {
   try {
     const generations = readdirSync4(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 : join12(slot, newest);
+    return newest === undefined ? undefined : join13(slot, newest);
   } catch {
     return;
   }
@@ -23177,7 +23717,7 @@ function readOpenCodeV2CachedPluginVersion(slot) {
   if (!generation)
     return;
   try {
-    const pkg = JSON.parse(readFileSync9(getOpenCodePluginPackageJsonPath(generation), "utf-8"));
+    const pkg = JSON.parse(readFileSync10(getOpenCodePluginPackageJsonPath(generation), "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -23191,7 +23731,7 @@ var init_opencode_plugin_cache = __esm(() => {
 });
 
 // src/commands/doctor-windows-holders.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 function assertWindowsStoresClosed(paths, processes) {
   if (processes.pi.state !== "known" || processes.pi.processIds.length > 0 || (processes.pi.inconclusivePids?.length ?? 0) > 0 || processes.processSnapshot?.source !== "cim") {
     throw new Error(`Windows process probe could not rule out OpenCode, Pi or ck-mc holders${processes.pi.processIds.length || processes.pi.inconclusivePids?.length ? ` (PID ${[...processes.pi.processIds, ...processes.pi.inconclusivePids ?? []].join(", ")})` : ""}`);
@@ -23207,7 +23747,7 @@ function assertWindowsStoresClosed(paths, processes) {
   if (blockers.length)
     throw new Error(`OpenCode, Pi or ck-mc process is running (${blockers.map(({ pid, imageName, commandLine }) => `${imageName ?? commandLine} PID ${pid}`).join(", ")})`);
   for (const path of [...new Set(paths)]) {
-    if (!existsSync12(path))
+    if (!existsSync13(path))
       continue;
     let db;
     let locked = false;
@@ -23231,7 +23771,7 @@ var init_doctor_windows_holders = __esm(async () => {
 
 // src/commands/doctor-opencode2-cache.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync13, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync14, rmSync as rmSync4 } from "node:fs";
 function runLsof(args, spawn) {
   const result = spawn("lsof", args, { encoding: "utf-8", timeout: 15000, windowsHide: true });
   if (result.error)
@@ -23246,7 +23786,7 @@ function probeHostProcessesUsing(targets, spawn = spawnSync3) {
   if (process.platform === "win32") {
     try {
       assertWindowsStoresClosed(targets.files.filter((path) => !/-(?:wal|shm)$/.test(path)), inspectWindowsProcessesSync());
-      if (targets.directories.some(existsSync13))
+      if (targets.directories.some(existsSync14))
         return {
           status: "unknown",
           reason: "Windows cannot rule out open files in plugin cache directories"
@@ -23259,8 +23799,8 @@ function probeHostProcessesUsing(targets, spawn = spawnSync3) {
       };
     }
   }
-  const files = targets.files.filter((file) => existsSync13(file));
-  const directories = targets.directories.filter((directory) => existsSync13(directory));
+  const files = targets.files.filter((file) => existsSync14(file));
+  const directories = targets.directories.filter((directory) => existsSync14(directory));
   const queries = [];
   if (files.length > 0)
     queries.push(["-w", "-t", "--", ...files]);
@@ -23335,7 +23875,7 @@ function removeOpenCodeV2PluginCacheSlot(slot, hostFiles, deps = {}) {
     return { action: "in_use", pids: use.pids };
   if (use.status === "unknown")
     return { action: "in_use_unknown", reason: use.reason };
-  const remove = deps.remove ?? ((path) => rmSync3(path, { recursive: true, force: true }));
+  const remove = deps.remove ?? ((path) => rmSync4(path, { recursive: true, force: true }));
   try {
     remove(slot);
   } catch (err) {
@@ -23355,9 +23895,9 @@ function checkOpenCodeV2PluginCache(options, deps = {}) {
   const slot = deps.slot ?? getOpenCodeV2PluginCacheSlot(undefined, distTag ?? "latest");
   const tagged = distTag ? { distTag } : {};
   if (options.referencedSpecs !== undefined && !options.referencedSpecs.has(distTag ?? "latest")) {
-    return existsSync13(slot) ? { action: "unused", slot, cached: readOpenCodeV2CachedPluginVersion(slot), ...tagged } : { action: "not_found", slot, unused: true, ...tagged };
+    return existsSync14(slot) ? { action: "unused", slot, cached: readOpenCodeV2CachedPluginVersion(slot), ...tagged } : { action: "not_found", slot, unused: true, ...tagged };
   }
-  if (!existsSync13(slot))
+  if (!existsSync14(slot))
     return { action: "not_found", slot, ...tagged };
   const cached = readOpenCodeV2CachedPluginVersion(slot);
   const latest = options.latestVersion ?? undefined;
@@ -23450,21 +23990,21 @@ var init_doctor_opencode2_cache = __esm(async () => {
 import { randomBytes as randomBytes2 } from "node:crypto";
 import {
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   readlinkSync as readlinkSync2,
-  renameSync as renameSync3,
-  rmSync as rmSync4,
-  statSync as statSync8,
-  writeFileSync as writeFileSync3
+  renameSync as renameSync4,
+  rmSync as rmSync5,
+  statSync as statSync9,
+  writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname7, resolve as resolve5 } from "node:path";
+import { dirname as dirname8, resolve as resolve5 } from "node:path";
 function resolveWriteTarget(targetPath) {
   let current = resolve5(targetPath);
   for (let hop = 0;hop < MAX_SYMLINK_HOPS; hop++) {
     const stat = lstatSync2(current, { throwIfNoEntry: false });
     if (!stat?.isSymbolicLink())
       return current;
-    current = resolve5(dirname7(current), readlinkSync2(current));
+    current = resolve5(dirname8(current), readlinkSync2(current));
   }
   throw new Error(`Too many levels of symbolic links resolving ${targetPath}`);
 }
@@ -23474,19 +24014,19 @@ function writeFileAtomic(targetPath, data, options = {}) {
     writeStorageFileAtomicSync(finalPath, data, true);
     return;
   }
-  mkdirSync3(dirname7(finalPath), { recursive: true });
-  const existing = statSync8(finalPath, { throwIfNoEntry: false });
+  mkdirSync4(dirname8(finalPath), { recursive: true });
+  const existing = statSync9(finalPath, { throwIfNoEntry: false });
   const mode = existing?.isFile() ? existing.mode & 511 : undefined;
   const tmpPath = `${finalPath}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
   try {
-    writeFileSync3(tmpPath, data, {
+    writeFileSync4(tmpPath, data, {
       encoding: "utf-8",
       flag: "wx",
       ...mode !== undefined ? { mode } : {}
     });
-    renameSync3(tmpPath, finalPath);
+    renameSync4(tmpPath, finalPath);
   } catch (error) {
-    rmSync4(tmpPath, { force: true });
+    rmSync5(tmpPath, { force: true });
     throw error;
   }
 }
@@ -23496,7 +24036,7 @@ var init_atomic_write = __esm(() => {
 });
 
 // src/lib/jsonc-config.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync11 } from "node:fs";
 function parseErrorLocation(content, error) {
   const lines = content.split(`
 `);
@@ -23512,9 +24052,9 @@ function parseErrorLocation(content, error) {
   return { line: messageLine ? Number.parseInt(messageLine, 10) : 1, column: 1 };
 }
 function readJsoncConfig(path) {
-  if (!existsSync14(path))
+  if (!existsSync15(path))
     return { kind: "missing" };
-  const content = readFileSync10(path, "utf-8");
+  const content = readFileSync11(path, "utf-8");
   try {
     const rejectedKeyPaths = [];
     const parsed = sanitizeParsedJson(import_comment_json.parse(content), {
@@ -23540,7 +24080,7 @@ function readJsoncConfigForUpdate(path) {
   return result.value;
 }
 function readJsoncTextForEdit(configPath) {
-  const raw = readFileSync10(configPath, "utf-8");
+  const raw = readFileSync11(configPath, "utf-8");
   return raw.startsWith(BYTE_ORDER_MARK) ? { bom: BYTE_ORDER_MARK, text: raw.slice(BYTE_ORDER_MARK.length) } : { bom: "", text: raw };
 }
 function assertJsoncConfigsParseable(paths) {
@@ -23629,15 +24169,15 @@ var init_jsonc_config = __esm(() => {
 });
 
 // src/lib/opencode-detect.ts
-import { existsSync as existsSync15, realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { join as join13 } from "node:path";
+import { existsSync as existsSync16, realpathSync as realpathSync2 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { join as join14 } from "node:path";
 function defaultDeps(overrides = {}) {
   const env = overrides.env ?? process.env;
   return {
-    exists: overrides.exists ?? existsSync15,
+    exists: overrides.exists ?? existsSync16,
     isExecutable: overrides.isExecutable ?? isExecutableFile,
-    home: overrides.home ?? (env.HOME?.trim() || homedir10()),
+    home: overrides.home ?? (env.HOME?.trim() || homedir11()),
     platform: overrides.platform ?? process.platform,
     env,
     onPath: overrides.onPath ?? findOnPath,
@@ -23645,7 +24185,7 @@ function defaultDeps(overrides = {}) {
   };
 }
 function stockCliBinary(d) {
-  return d.platform === "win32" ? join13(d.home, ".opencode", "bin", "opencode.exe") : join13(d.home, ".opencode", "bin", "opencode");
+  return d.platform === "win32" ? join14(d.home, ".opencode", "bin", "opencode.exe") : join14(d.home, ".opencode", "bin", "opencode");
 }
 function extraCliCandidates(d) {
   if (d.platform === "win32") {
@@ -23654,25 +24194,25 @@ function extraCliCandidates(d) {
     const userprofile = d.env.USERPROFILE ?? d.home;
     const out = [];
     if (appdata) {
-      out.push(join13(appdata, "npm", "opencode.cmd"));
-      out.push(join13(appdata, "npm", "opencode.exe"));
+      out.push(join14(appdata, "npm", "opencode.cmd"));
+      out.push(join14(appdata, "npm", "opencode.exe"));
     }
     if (localappdata) {
-      out.push(join13(localappdata, "Microsoft", "WinGet", "Links", "opencode.exe"));
-      out.push(join13(localappdata, "opencode", "bin", "opencode.exe"));
+      out.push(join14(localappdata, "Microsoft", "WinGet", "Links", "opencode.exe"));
+      out.push(join14(localappdata, "opencode", "bin", "opencode.exe"));
     }
     if (userprofile) {
-      out.push(join13(userprofile, "scoop", "shims", "opencode.exe"));
+      out.push(join14(userprofile, "scoop", "shims", "opencode.exe"));
     }
     return out;
   }
   return [
     "/usr/local/bin/opencode",
     "/opt/homebrew/bin/opencode",
-    join13(d.home, ".local", "bin", "opencode"),
-    join13(d.home, ".local", "share", "mise", "shims", "opencode"),
-    join13(d.home, ".asdf", "shims", "opencode"),
-    join13(d.home, ".volta", "bin", "opencode")
+    join14(d.home, ".local", "bin", "opencode"),
+    join14(d.home, ".local", "share", "mise", "shims", "opencode"),
+    join14(d.home, ".asdf", "shims", "opencode"),
+    join14(d.home, ".volta", "bin", "opencode")
   ];
 }
 function openChamberCliCandidates(d) {
@@ -23680,8 +24220,8 @@ function openChamberCliCandidates(d) {
     return [];
   const bundled = ["Contents", "Resources", "opencode-cli", "opencode"];
   return [
-    join13("/Applications", "OpenChamber.app", ...bundled),
-    join13(d.home, "Applications", "OpenChamber.app", ...bundled)
+    join14("/Applications", "OpenChamber.app", ...bundled),
+    join14(d.home, "Applications", "OpenChamber.app", ...bundled)
   ];
 }
 function canonicalPath(d, path) {
@@ -23702,29 +24242,29 @@ function xdgConfigHome(d) {
   const xdg = d.env.XDG_CONFIG_HOME;
   if (xdg && xdg.length > 0)
     return xdg;
-  return join13(d.home, ".config");
+  return join14(d.home, ".config");
 }
 function desktopUserDataDir(d, appId) {
   switch (d.platform) {
     case "darwin":
-      return join13(d.home, "Library", "Application Support", appId);
+      return join14(d.home, "Library", "Application Support", appId);
     case "win32":
-      return join13(d.env.APPDATA ?? join13(d.home, "AppData", "Roaming"), appId);
+      return join14(d.env.APPDATA ?? join14(d.home, "AppData", "Roaming"), appId);
     default:
-      return join13(xdgConfigHome(d), appId);
+      return join14(xdgConfigHome(d), appId);
   }
 }
 function desktopAppPaths(d) {
   switch (d.platform) {
     case "darwin":
-      return ["/Applications/OpenCode.app", join13(d.home, "Applications", "OpenCode.app")];
+      return ["/Applications/OpenCode.app", join14(d.home, "Applications", "OpenCode.app")];
     case "win32": {
-      const localappdata = d.env.LOCALAPPDATA ?? join13(d.home, "AppData", "Local");
-      return [join13(localappdata, "Programs", "OpenCode", "OpenCode.exe")];
+      const localappdata = d.env.LOCALAPPDATA ?? join14(d.home, "AppData", "Local");
+      return [join14(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 : join13(d.home, ".local", "share");
-      return OPENCODE_DESKTOP_APP_IDS.map((appId) => join13(dataHome, "applications", `${appId}.desktop`));
+      const dataHome = d.env.XDG_DATA_HOME && d.env.XDG_DATA_HOME.length > 0 ? d.env.XDG_DATA_HOME : join14(d.home, ".local", "share");
+      return OPENCODE_DESKTOP_APP_IDS.map((appId) => join14(dataHome, "applications", `${appId}.desktop`));
     }
   }
 }
@@ -23751,7 +24291,7 @@ function detectOpenCodeInstallations(deps) {
     }
   }
   for (const appId of OPENCODE_DESKTOP_APP_IDS) {
-    const marker = join13(desktopUserDataDir(d, appId), OPENCODE_DESKTOP_SETTINGS_FILE);
+    const marker = join14(desktopUserDataDir(d, appId), OPENCODE_DESKTOP_SETTINGS_FILE);
     if (d.exists(marker)) {
       addCandidate(installations, seenRealpaths, d, marker, "desktop", "desktop");
     }
@@ -23849,8 +24389,8 @@ var OPENCODE_BINARY_ENV = "MAGIC_CONTEXT_OPENCODE_BINARY", OPENCODE_VERSION_PROB
 var init_opencode_helpers = () => {};
 
 // src/adapters/opencode.ts
-import { existsSync as existsSync16, readFileSync as readFileSync11, statSync as statSync9 } from "node:fs";
-import { dirname as dirname8, isAbsolute as isAbsolute5, parse as parsePath, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync12, statSync as statSync10 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute5, parse as parsePath, resolve as resolve6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 class OpenCodeAdapter {
@@ -23881,7 +24421,7 @@ class OpenCodeAdapter {
     if (paths.opencodeConfigFormat === "none")
       return false;
     try {
-      const raw = readFileSync11(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync12(paths.opencodeConfig, "utf-8");
       const cfg = import_comment_json2.parse(raw);
       return readPluginEntries(cfg).some(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME));
     } catch {
@@ -23917,7 +24457,7 @@ class OpenCodeAdapter {
           configPath: target
         };
       }
-      const raw = readFileSync11(target, "utf-8");
+      const raw = readFileSync12(target, "utf-8");
       const cfg = import_comment_json2.parse(raw);
       if (cfg === null || typeof cfg !== "object") {
         return {
@@ -23929,7 +24469,7 @@ class OpenCodeAdapter {
       }
       const entries = readPluginEntries(cfg);
       const existing = entries.find(({ entry }) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME));
-      const existingDev = entries.find(({ entry }) => isDevPathPluginEntry(entry, dirname8(target)));
+      const existingDev = entries.find(({ entry }) => isDevPathPluginEntry(entry, dirname9(target)));
       if (!existing && !existingDev) {
         const list = Array.isArray(cfg[this.writeKey]) ? cfg[this.writeKey] : [];
         list.push(OPENCODE_PLUGIN_ENTRY_WITH_VERSION);
@@ -23992,7 +24532,7 @@ class OpenCodeAdapter {
       };
     }
     try {
-      const raw = readFileSync11(target, "utf-8");
+      const raw = readFileSync12(target, "utf-8");
       const cfg = import_comment_json2.parse(raw);
       if (cfg === null || typeof cfg !== "object") {
         return {
@@ -24043,9 +24583,9 @@ class OpenCodeAdapter {
   }
   getPluginCacheInfo() {
     const legacyPath = getOpenCodePluginCacheDir();
-    const legacyExists = existsSync16(legacyPath);
+    const legacyExists = existsSync17(legacyPath);
     const slot = getOpenCodeV2PluginCacheSlot();
-    const slotExists = existsSync16(slot);
+    const slotExists = existsSync17(slot);
     const caches = [];
     if (legacyExists || !slotExists) {
       caches.push({
@@ -24103,7 +24643,7 @@ class OpenCodeAdapter {
     if (paths.opencodeConfigFormat === "none")
       return "latest";
     try {
-      const cfg = import_comment_json2.parse(readFileSync11(paths.opencodeConfig, "utf-8"));
+      const cfg = import_comment_json2.parse(readFileSync12(paths.opencodeConfig, "utf-8"));
       return readConfiguredOpenCodePluginSpec(cfg);
     } catch {
       return "latest";
@@ -24115,10 +24655,10 @@ class OpenCodeAdapter {
       return readOpenCodeV2CachedPluginVersion(slot) ?? null;
     }
     for (const candidate of getOpenCodePluginPackageJsonPaths()) {
-      if (!existsSync16(candidate))
+      if (!existsSync17(candidate))
         continue;
       try {
-        const raw = readFileSync11(candidate, "utf-8");
+        const raw = readFileSync12(candidate, "utf-8");
         const pkg = JSON.parse(raw);
         if (typeof pkg.version === "string")
           return pkg.version;
@@ -24156,16 +24696,16 @@ function isDevPathPluginEntry(entry, configDir) {
     } else {
       localPath = resolve6(configDir, candidate);
     }
-    if (statSync9(localPath).isFile())
-      localPath = dirname8(localPath);
+    if (statSync10(localPath).isFile())
+      localPath = dirname9(localPath);
     const root = parsePath(localPath).root;
     while (localPath !== root) {
       const packagePath = resolve6(localPath, "package.json");
-      if (existsSync16(packagePath)) {
-        const pkg = JSON.parse(readFileSync11(packagePath, "utf8"));
+      if (existsSync17(packagePath)) {
+        const pkg = JSON.parse(readFileSync12(packagePath, "utf8"));
         return pkg.name === OPENCODE_PLUGIN_NAME;
       }
-      localPath = dirname8(localPath);
+      localPath = dirname9(localPath);
     }
   } catch {}
   return false;
@@ -24181,8 +24721,8 @@ function matchesPluginEntry(entry, pkgName) {
   return head === pkgName;
 }
 function ensureDir2(filePath) {
-  const dir = dirname8(filePath);
-  if (!existsSync16(dir)) {
+  const dir = dirname9(filePath);
+  if (!existsSync17(dir)) {
     const { mkdirSync } = __require("node:fs");
     mkdirSync(dir, { recursive: true });
   }
@@ -24203,8 +24743,8 @@ var init_opencode = __esm(async () => {
 });
 
 // src/lib/pi-package-entry.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "node:fs";
-import { isAbsolute as isAbsolute6, join as join14 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync13 } from "node:fs";
+import { isAbsolute as isAbsolute6, join as join15 } from "node:path";
 function stripNpmPrefix(value) {
   return value.startsWith("npm:") ? value.slice("npm:".length) : value;
 }
@@ -24259,11 +24799,11 @@ function hasPiMagicContextPackage(entries, agentDir = getPiAgentConfigDir()) {
   return entries.some((entry) => isConfiguredPiMagicContextEntry(entry, agentDir));
 }
 function isPiMagicContextPackageDir(dir) {
-  const packageJson = join14(dir, "package.json");
-  if (!existsSync17(packageJson))
+  const packageJson = join15(dir, "package.json");
+  if (!existsSync18(packageJson))
     return false;
   try {
-    const pkg = JSON.parse(readFileSync12(packageJson, "utf-8"));
+    const pkg = JSON.parse(readFileSync13(packageJson, "utf-8"));
     return typeof pkg.name === "string" && pkg.name === PI_MAGIC_CONTEXT_PACKAGE_NAME;
   } catch {
     return false;
@@ -24275,7 +24815,7 @@ function localPiMagicContextPackageDir(entry, agentDir) {
   if (!spec || spec.startsWith("npm:"))
     return null;
   const path = spec.startsWith("file:") ? spec.slice("file:".length) : spec;
-  const dir = isAbsolute6(path) ? path : join14(agentDir, path);
+  const dir = isAbsolute6(path) ? path : join15(agentDir, path);
   return isPiMagicContextPackageDir(dir) ? dir : null;
 }
 function isConfiguredPiMagicContextEntry(entry, agentDir) {
@@ -24299,8 +24839,8 @@ var init_pi_package_entry = __esm(() => {
 });
 
 // src/adapters/pi.ts
-import { existsSync as existsSync18 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
 
 class PiAdapter {
   kind = "pi";
@@ -24437,8 +24977,8 @@ function writePiSettings(settings) {
 `);
 }
 function ensureDir3(filePath) {
-  const dir = dirname9(filePath);
-  if (!existsSync18(dir)) {
+  const dir = dirname10(filePath);
+  if (!existsSync19(dir)) {
     const { mkdirSync } = __require("node:fs");
     mkdirSync(dir, { recursive: true });
   }
@@ -24756,7 +25296,7 @@ var init_fail_closed_block = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/message-fts-rowid-map.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function getUpsertMapStatement(db) {
   let statement = upsertMapStatements.get(db);
   if (!statement) {
@@ -24858,7 +25398,7 @@ var MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE = 100, BACKFILL_STATE_ID = 1, EMPT
 var init_message_fts_rowid_map = __esm(async () => {
   init_write_transaction_timing();
   await init_sqlite();
-  EMPTY_INDEX_CONTENT_HASH = createHash("sha256").update("").digest("hex");
+  EMPTY_INDEX_CONTENT_HASH = createHash2("sha256").update("").digest("hex");
   upsertMapStatements = new WeakMap;
   rangeReadyStatements = new WeakMap;
   updateTimeStatements = new WeakMap;
@@ -24866,7 +25406,7 @@ var init_message_fts_rowid_map = __esm(async () => {
 });
 
 // ../plugin/src/features/magic-context/lkg-prefix-chunks.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 function splitLkgPrefix(jsonPrefix) {
   const chunks = [];
   let start = 0;
@@ -24883,10 +25423,10 @@ function splitLkgPrefix(jsonPrefix) {
   return chunks;
 }
 function hashLkgChunk(body) {
-  return createHash2("sha256").update(body).digest("hex");
+  return createHash3("sha256").update(body).digest("hex");
 }
 function hashLkgChunkList(chunkHashes) {
-  return createHash2("sha256").update(chunkHashes.join(`
+  return createHash3("sha256").update(chunkHashes.join(`
 `)).digest("hex");
 }
 function layoutLkgPrefix(jsonPrefix) {
@@ -26015,11 +26555,11 @@ function installCompartmentHistoryVersions(db) {
 }
 
 // ../plugin/src/features/magic-context/memory/project-identity-cache.ts
-import { createHash as createHash3 } from "node:crypto";
-import { readFileSync as readFileSync13 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { readFileSync as readFileSync14 } from "node:fs";
 import path4 from "node:path";
 function cachePath(directory, storageDir = getMagicContextStorageDir()) {
-  const hash = createHash3("sha256").update(projectDirectoryKey(directory)).digest("hex");
+  const hash = createHash4("sha256").update(projectDirectoryKey(directory)).digest("hex");
   return path4.join(storageDir, "project-identities", `${hash}.json`);
 }
 function rememberGitIdentity(directory, identity) {
@@ -26030,7 +26570,7 @@ function rememberGitIdentity(directory, identity) {
 }
 function readRememberedGitIdentity(directory, storageDir) {
   try {
-    const record = JSON.parse(readFileSync13(cachePath(directory, storageDir), "utf8"));
+    const record = JSON.parse(readFileSync14(cachePath(directory, storageDir), "utf8"));
     if (record.directory === projectDirectoryKey(directory) && /^git:[0-9a-f]{7,64}$/.test(record.identity))
       return record.identity;
   } catch {}
@@ -26044,9 +26584,9 @@ var init_project_identity_cache = __esm(() => {
 
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync19, realpathSync as realpathSync3, statSync as statSync10 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync20, realpathSync as realpathSync3, statSync as statSync11 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
 import path5 from "node:path";
 function asError(error) {
   return error instanceof Error ? error : undefined;
@@ -26086,7 +26626,7 @@ function getErrorStderr(error) {
 }
 function directoryFallback(directory) {
   const canonical = path5.resolve(directory);
-  const hash = createHash4("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
+  const hash = createHash5("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
   return `dir:${hash}`;
 }
 function rememberedIdentityOrDirectoryFallback(canonical) {
@@ -26094,7 +26634,7 @@ function rememberedIdentityOrDirectoryFallback(canonical) {
 }
 function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
   try {
-    const stat = statSync10(canonicalDirectory);
+    const stat = statSync11(canonicalDirectory);
     if (!stat.isDirectory()) {
       throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
     }
@@ -26155,10 +26695,10 @@ function classifyGitError(error, rawDirectory) {
   }
   return new ProjectIdentityError("unknown", rawDirectory, "git rev-list failed while resolving project identity", asError(error));
 }
-function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectPermission) {
+function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectPermission, options = {}) {
   assertProjectAllowed(directory, allowHomeProject);
   const canonical = path5.resolve(directory);
-  const cached = identityCache.get(canonical);
+  const cached = options.cache === false ? undefined : identityCache.get(canonical);
   if (cached !== undefined) {
     return cached;
   }
@@ -26189,6 +26729,8 @@ function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectP
     throw new ProjectIdentityError("unknown", directory, "git rev-list returned no valid root commit hash");
   }
   const identity = `git:${rootCommit}`;
+  if (options.cache === false)
+    return identity;
   identityCache.set(canonical, identity);
   lastKnownGitIdentityCache.set(canonical, identity);
   rememberGitIdentity(canonical, identity);
@@ -26224,7 +26766,7 @@ function nearestLastKnownGitIdentity(canonical) {
       const cached = lastKnownGitIdentity(current);
       if (cached !== undefined)
         return { identity: cached, source: current };
-      if (existsSync19(path5.join(current, ".git")))
+      if (existsSync20(path5.join(current, ".git")))
         break;
       const parent = path5.dirname(current);
       if (parent === current)
@@ -26347,7 +26889,7 @@ function hasGitDir(canonical) {
 function gitRootInAncestorChain(startDirectory) {
   let current = startDirectory;
   while (true) {
-    if (existsSync19(path5.join(current, ".git"))) {
+    if (existsSync20(path5.join(current, ".git"))) {
       try {
         return realpathSync3.native(current);
       } catch {
@@ -26375,7 +26917,7 @@ function gitRootDirectory(canonical) {
     return null;
   }
 }
-var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, linkedGitWorktreeCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, sessionIdentityCache, homeProjectPermission = false, pausedIdentityReasons, pausedIdentityLogged, execFileSyncForIdentity, userHomeDirectoryForIdentity = () => homedir11(), nowMs = () => Date.now(), ProjectIdentityError;
+var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, linkedGitWorktreeCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, sessionIdentityCache, homeProjectPermission = false, pausedIdentityReasons, pausedIdentityLogged, execFileSyncForIdentity, userHomeDirectoryForIdentity = () => homedir12(), nowMs = () => Date.now(), ProjectIdentityError;
 var init_project_identity = __esm(() => {
   init_logger();
   init_project_identity_cache();
@@ -29659,7 +30201,7 @@ var init_tool_definition_tokens = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 function resolveOpencodeDbPath() {
   return resolveOpenCodeDbPath().path;
 }
@@ -29696,7 +30238,7 @@ function runToolOwnerBackfill(db) {
     return result;
   }
   const opencodeDbPath = resolveOpencodeDbPath();
-  if (!existsSync20(opencodeDbPath)) {
+  if (!existsSync21(opencodeDbPath)) {
     log(`[backfill] OpenCode DB not found at ${opencodeDbPath} — marking all unbackfilled sessions as skipped. Lazy adoption (defense-in-depth) handles legacy rows at runtime.`);
     markAllUnbackfilledSessionsSkipped(db);
     result.sessionsSkippedNoOcDb = countSessionsByStatus(db, "skipped");
@@ -30300,7 +30842,10 @@ function isRecord2(value) {
 }
 
 // ../plugin/src/shared/tag-owner-id.ts
-var init_tag_owner_id = () => {};
+var PI_FALLBACK_PREFIXES_JSON;
+var init_tag_owner_id = __esm(() => {
+  PI_FALLBACK_PREFIXES_JSON = JSON.stringify([..."pi-msg-"].reduce((prefixes, char) => prefixes.flatMap((prefix) => /[a-z]/.test(char) ? [prefix + char, prefix + char.toUpperCase()] : [prefix + char]), [""]));
+});
 
 // ../plugin/src/hooks/magic-context/image-token-estimate.ts
 var JPEG_SCAN_LIMIT_BYTES;
@@ -31666,6 +32211,8 @@ function runSessionWarmupWorker(input, options) {
         finish({ delta: reply.delta });
       else if (reply.kind === "indexed")
         finish({ inserted: reply.inserted, measurements: reply.measurements });
+      else if (reply.kind === "orphan-sweep")
+        finish({ orphanSweep: reply.result });
       else
         finish({ failure: "worker-error", detail: reply.error });
     });
@@ -33193,6 +33740,14 @@ function readSessionChunk(sessionId, tokenBudget, offset = 1, eligibleEndOrdinal
     pinComponentWhenFormattedBudgetCrosses(msg.ordinal, text);
   }
   if (flushCurrentBlock() && pendingNoiseMeta.length > 0) {
+    const lastNoise = pendingNoiseMeta[pendingNoiseMeta.length - 1];
+    if (messagesProcessed > 0 && lastNoise) {
+      lineMeta.push(...pendingNoiseMeta);
+      messagesProcessed += pendingNoiseMeta.length;
+      lastOrdinal = lastNoise.ordinal;
+      lastMessageId = lastNoise.messageId;
+      pendingNoiseMeta = [];
+    }
     highestScannedOrdinal = Math.max(highestScannedOrdinal, pendingNoiseMeta[pendingNoiseMeta.length - 1]?.ordinal ?? highestScannedOrdinal);
   }
   const toolOnlyRanges = [];
@@ -33396,14 +33951,14 @@ var init_message_time_backfill = __esm(async () => {
 
 // ../plugin/src/features/magic-context/storage-db.ts
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync14,
+  readFileSync as readFileSync15,
   rmdirSync,
-  statSync as statSync11,
+  statSync as statSync12,
   unlinkSync as unlinkSync3
 } from "node:fs";
-import { basename as basename3, dirname as dirname10, join as join15, resolve as resolve7 } from "node:path";
+import { basename as basename3, dirname as dirname11, join as join16, resolve as resolve7 } from "node:path";
 function ensureSecureStorageDir(dir) {
   ensureStorageDirectorySync(dir);
 }
@@ -33424,17 +33979,17 @@ function installBootBusyTimeout(db, dbPath, timeoutMs, report = log) {
 }
 function resolveDatabasePath(dbPathOverride) {
   if (dbPathOverride) {
-    return { dbDir: dirname10(dbPathOverride), dbPath: dbPathOverride };
+    return { dbDir: dirname11(dbPathOverride), dbPath: dbPathOverride };
   }
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join15(dbDir, "context.db") };
+  return { dbDir, dbPath: join16(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync21(targetDbPath))
+  if (existsSync22(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join15(legacyDir, "context.db");
-  if (!existsSync21(legacyDbPath))
+  const legacyDbPath = join16(legacyDir, "context.db");
+  if (!existsSync22(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
   ensureSecureStorageDir(targetDbDir);
@@ -33451,8 +34006,8 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   }
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join15(targetDbDir, `context.db${suffix}`);
-    if (existsSync21(src)) {
+    const dst = join16(targetDbDir, `context.db${suffix}`);
+    if (existsSync22(src)) {
       try {
         copyStorageFileSync(src, dst);
       } catch (error) {
@@ -33460,9 +34015,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join15(legacyDir, "models");
-  const targetModelsDir = join15(targetDbDir, "models");
-  if (existsSync21(legacyModelsDir) && !existsSync21(targetModelsDir)) {
+  const legacyModelsDir = join16(legacyDir, "models");
+  const targetModelsDir = join16(targetDbDir, "models");
+  if (existsSync22(legacyModelsDir) && !existsSync22(targetModelsDir)) {
     try {
       copyStorageTreeSync(legacyModelsDir, targetModelsDir);
     } catch (error) {
@@ -33570,7 +34125,7 @@ function classifyJunkDiscovery(portFile, raw, staleFiles) {
 function inspectRpcServerDiscovery(storageDir, processes, options) {
   const deadline = options?.deadlineMs === undefined ? Number.POSITIVE_INFINITY : Date.now() + options.deadlineMs;
   let progressAt = Date.now() + 3000;
-  const rpcRoot = join15(storageDir, "rpc");
+  const rpcRoot = join16(storageDir, "rpc");
   let projectEntries;
   try {
     projectEntries = rpcDiscoveryFs.readdirSync(rpcRoot, { withFileTypes: true });
@@ -33584,7 +34139,7 @@ function inspectRpcServerDiscovery(storageDir, processes, options) {
   for (const projectEntry of projectEntries) {
     if (!projectEntry.isDirectory())
       continue;
-    const projectDir = join15(rpcRoot, projectEntry.name);
+    const projectDir = join16(rpcRoot, projectEntry.name);
     let entries;
     try {
       entries = rpcDiscoveryFs.readdirSync(projectDir);
@@ -33595,7 +34150,7 @@ function inspectRpcServerDiscovery(storageDir, processes, options) {
     }
     for (const entry of entries) {
       if (entry === "port" || entry.startsWith("port-") && entry.endsWith(".json")) {
-        portFiles.push(join15(projectDir, entry));
+        portFiles.push(join16(projectDir, entry));
       }
     }
   }
@@ -33698,7 +34253,7 @@ function inspectRpcServerDiscovery(storageDir, processes, options) {
   return { state: "stale", serverPids: [], staleFiles };
 }
 function pruneEmptyRpcDiscoveryDirs(storageDir) {
-  const rpcRoot = join15(storageDir, "rpc");
+  const rpcRoot = join16(storageDir, "rpc");
   let entries;
   try {
     entries = rpcDiscoveryFs.readdirSync(rpcRoot, { withFileTypes: true });
@@ -33710,7 +34265,7 @@ function pruneEmptyRpcDiscoveryDirs(storageDir) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const projectDir = join15(rpcRoot, entry.name);
+    const projectDir = join16(rpcRoot, entry.name);
     try {
       if (rpcDiscoveryFs.readdirSync(projectDir).length > 0)
         continue;
@@ -33724,12 +34279,12 @@ function pruneEmptyRpcDiscoveryDirs(storageDir) {
   return removed;
 }
 function removeRpcDiscoveryRecords(storageDir, files) {
-  const rpcRoot = resolve7(join15(storageDir, "rpc"));
+  const rpcRoot = resolve7(join16(storageDir, "rpc"));
   const removed = [];
   const failed = [];
   for (const file of files) {
-    const projectDir = dirname10(resolve7(file));
-    if (dirname10(projectDir) !== rpcRoot || !basename3(file).startsWith("port")) {
+    const projectDir = dirname11(resolve7(file));
+    if (dirname11(projectDir) !== rpcRoot || !basename3(file).startsWith("port")) {
       failed.push({ file, error: "not an RPC discovery record" });
       continue;
     }
@@ -33776,7 +34331,7 @@ function isDefaultSharedDatabasePath(dbPath) {
   if (!process.env.XDG_DATA_HOME && (process.env.MAGIC_CONTEXT_TEST_DATA_DIR || false)) {
     return false;
   }
-  return resolve7(dbPath) === resolve7(join15(getMagicContextStorageDir(), "context.db"));
+  return resolve7(dbPath) === resolve7(join16(getMagicContextStorageDir(), "context.db"));
 }
 function migrationBlockingPiPids(dbPath, discovery, discoveredPiPids) {
   if (isDefaultSharedDatabasePath(dbPath))
@@ -33886,7 +34441,7 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
   }
   setDatabase(db);
   loadToolDefinitionMeasurements(db);
-  tightenStorageTree(dirname10(dbPath));
+  tightenStorageTree(dirname11(dbPath));
   databases.set(dbPath, db);
   pathByDatabase.set(db, dbPath);
   persistenceByDatabase.set(db, true);
@@ -35181,7 +35736,7 @@ function openDatabase(dbPathOrOptions) {
     }
     ensureSecureStorageDir(dbDir);
     tightenStorageTree(dbDir);
-    if (!existsSync21(dbPath) && shouldEnforcePrivateStoragePermissions()) {
+    if (!existsSync22(dbPath) && shouldEnforcePrivateStoragePermissions()) {
       try {
         writeStorageFileSync(dbPath, new Uint8Array, { flag: "wx" });
       } catch (error) {
@@ -35267,8 +35822,8 @@ var init_storage_db = __esm(async () => {
   RPC_DISCOVERY_PARSE_GRACE_MS = 10 * 60 * 1000;
   defaultRpcDiscoveryFs = {
     readdirSync: (path, options) => options?.withFileTypes ? readdirSync5(path, { withFileTypes: true }) : readdirSync5(path),
-    readFileSync: (path, encoding) => String(readFileSync14(path, encoding)),
-    statSync: (path) => ({ mtimeMs: statSync11(path).mtimeMs }),
+    readFileSync: (path, encoding) => String(readFileSync15(path, encoding)),
+    statSync: (path) => ({ mtimeMs: statSync12(path).mtimeMs }),
     unlinkSync: (path) => unlinkSync3(path),
     rmdirSync: (path) => rmdirSync(path)
   };
@@ -35282,14 +35837,14 @@ var init_storage_db = __esm(async () => {
 });
 
 // src/lib/database-access.ts
-import { existsSync as existsSync22, rmSync as rmSync5 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { existsSync as existsSync23, rmSync as rmSync6 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
 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 });
@@ -35338,7 +35893,7 @@ function openExistingContextDatabaseForMutation(path) {
 async function backupDatabaseSnapshot(db, sourcePath, destination) {
   const serializable = db;
   if (typeof serializable.serialize === "function") {
-    ensureStorageDirectorySync(dirname11(destination));
+    ensureStorageDirectorySync(dirname12(destination));
     writeStorageFileSync(destination, serializable.serialize(), { flag: "wx" });
     return;
   }
@@ -35347,7 +35902,7 @@ async function backupDatabaseSnapshot(db, sourcePath, destination) {
   if (typeof sqlite.backup !== "function") {
     throw new Error("The active SQLite runtime does not provide a snapshot backup API");
   }
-  if (existsSync22(destination)) {
+  if (existsSync23(destination)) {
     throw new Error(`Refusing to overwrite existing backup ${destination}`);
   }
   const reader = new Database(sourcePath, { readonly: true });
@@ -35355,7 +35910,7 @@ async function backupDatabaseSnapshot(db, sourcePath, destination) {
   try {
     await sqlite.backup(reader, destination);
   } catch (error) {
-    rmSync5(destination, { force: true });
+    rmSync6(destination, { force: true });
     throw error;
   } finally {
     reader.close();
@@ -35633,11 +36188,11 @@ var init_dreamer_setup = __esm(() => {
 });
 
 // src/commands/setup-pi.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync4 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync5 } from "node:fs";
+import { dirname as dirname13 } from "node:path";
 function ensureDir4(path) {
-  if (!existsSync23(path))
-    mkdirSync4(path, { recursive: true });
+  if (!existsSync24(path))
+    mkdirSync5(path, { recursive: true });
 }
 async function getDefaultPrompts() {
   await Promise.resolve().then(() => init_prompts());
@@ -35669,7 +36224,7 @@ function comparePiVersion(a, b) {
 }
 function writePiSettingsPackage(settingsPath, packageSource = PI_PACKAGE_SOURCE) {
   const settings = readJsoncConfigForUpdate(settingsPath);
-  ensureDir4(dirname12(settingsPath));
+  ensureDir4(dirname13(settingsPath));
   if (settings.packages !== undefined && !Array.isArray(settings.packages)) {
     throw new Error(`Refusing to rewrite ${settingsPath}: "packages" is ${typeof settings.packages}, expected an array. Fix it by hand, then rerun setup.`);
   }
@@ -35700,7 +36255,7 @@ function removePiSettingsPackage(settingsPath, packageSource = PI_PACKAGE_SOURCE
 }
 function writeMagicContextConfig(configPath, options) {
   const config = readMagicContextConfigForSetup(configPath);
-  ensureDir4(dirname12(configPath));
+  ensureDir4(dirname13(configPath));
   if (!config.$schema) {
     config.$schema = "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json";
   }
@@ -36091,16 +36646,16 @@ var init_setup_omp = __esm(() => {
 });
 
 // ../plugin/src/shared/opencode-config-dir.ts
-import { homedir as homedir12 } from "node:os";
-import { join as join16, resolve as resolve8 } from "node:path";
+import { homedir as homedir13 } from "node:os";
+import { join as join17, resolve as resolve8 } from "node:path";
 function resolveHomeDir() {
-  return process.env.HOME?.trim() || homedir12();
+  return process.env.HOME?.trim() || homedir13();
 }
 function getOpenCodeGlobalConfigDir() {
   if (process.platform === "win32") {
-    return join16(resolveHomeDir(), ".config", "opencode");
+    return join17(resolveHomeDir(), ".config", "opencode");
   }
-  return join16(process.env.XDG_CONFIG_HOME || join16(resolveHomeDir(), ".config"), "opencode");
+  return join17(process.env.XDG_CONFIG_HOME || join17(resolveHomeDir(), ".config"), "opencode");
 }
 function getEnvConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
@@ -36116,14 +36671,14 @@ function getOpenCodeConfigPaths(options) {
   const configDir = getOpenCodeConfigDir2(options);
   return {
     configDir,
-    configJson: join16(configDir, "opencode.json"),
-    configJsonc: join16(configDir, "opencode.jsonc"),
-    packageJson: join16(configDir, "package.json"),
-    omoConfig: join16(configDir, "magic-context.jsonc")
+    configJson: join17(configDir, "opencode.json"),
+    configJsonc: join17(configDir, "opencode.jsonc"),
+    packageJson: join17(configDir, "package.json"),
+    omoConfig: join17(configDir, "magic-context.jsonc")
   };
 }
 function getOpenCodeConfigDirs() {
-  const dirs = [getOpenCodeGlobalConfigDir(), join16(resolveHomeDir(), ".opencode")];
+  const dirs = [getOpenCodeGlobalConfigDir(), join17(resolveHomeDir(), ".opencode")];
   const envDir = getEnvConfigDir();
   if (envDir)
     dirs.push(envDir);
@@ -36132,8 +36687,8 @@ function getOpenCodeConfigDirs() {
 var init_opencode_config_dir = () => {};
 
 // ../plugin/src/shared/conflict-detector.ts
-import { homedir as homedir13 } from "node:os";
-import { join as join17 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { join as join18 } from "node:path";
 function detectConflicts(directory, options) {
   const compactionEnabled = options?.compactionEnabled ?? true;
   const hostGeneration = options?.hostGeneration ?? "v1";
@@ -36200,19 +36755,19 @@ function checkCompaction(directory, hostGeneration) {
 function openCodeConfigFileChain(directory, hostGeneration) {
   const globalDir = getOpenCodeGlobalConfigDir();
   const wellKnown = [
-    join17(globalDir, "config.json"),
-    join17(globalDir, "opencode.json"),
-    join17(globalDir, "opencode.jsonc")
+    join18(globalDir, "config.json"),
+    join18(globalDir, "opencode.json"),
+    join18(globalDir, "opencode.jsonc")
   ];
-  const globalSupplementary = getOpenCodeConfigDirs().filter((dir) => dir !== globalDir).flatMap((dir) => [join17(dir, "opencode.json"), join17(dir, "opencode.jsonc")]);
+  const globalSupplementary = getOpenCodeConfigDirs().filter((dir) => dir !== globalDir).flatMap((dir) => [join18(dir, "opencode.json"), join18(dir, "opencode.jsonc")]);
   const explicitConfig = process.env.OPENCODE_CONFIG?.trim();
   const explicit = explicitConfig ? [explicitConfig] : [];
   const disableProjectConfig = process.env.OPENCODE_DISABLE_PROJECT_CONFIG?.toLowerCase();
   const skipProject = hostGeneration === "v1" && (disableProjectConfig === "true" || disableProjectConfig === "1");
-  const direct = skipProject ? [] : [join17(directory, "opencode.json"), join17(directory, "opencode.jsonc")];
+  const direct = skipProject ? [] : [join18(directory, "opencode.json"), join18(directory, "opencode.jsonc")];
   const projectSupplementary = skipProject ? [] : [
-    join17(directory, ".opencode", "opencode.json"),
-    join17(directory, ".opencode", "opencode.jsonc")
+    join18(directory, ".opencode", "opencode.json"),
+    join18(directory, ".opencode", "opencode.jsonc")
   ];
   const files = hostGeneration === "v2" ? [
     ...wellKnown,
@@ -36299,10 +36854,10 @@ function collectPluginEntries(directory) {
     }
   };
   for (const configPath of [
-    join17(directory, ".opencode", "opencode.jsonc"),
-    join17(directory, ".opencode", "opencode.json"),
-    join17(directory, "opencode.jsonc"),
-    join17(directory, "opencode.json")
+    join18(directory, ".opencode", "opencode.jsonc"),
+    join18(directory, ".opencode", "opencode.json"),
+    join18(directory, "opencode.jsonc"),
+    join18(directory, "opencode.json")
   ]) {
     const config = readJsoncFile(configPath);
     pushFrom(config?.plugin);
@@ -36312,7 +36867,7 @@ function collectPluginEntries(directory) {
     for (const dir of getOpenCodeConfigDirs()) {
       const names = dir === globalDir ? ["config.json", "opencode.json", "opencode.jsonc"] : ["opencode.json", "opencode.jsonc"];
       for (const name of names) {
-        const config = readJsoncFile(join17(dir, name));
+        const config = readJsoncFile(join18(dir, name));
         pushFrom(config?.plugin);
       }
     }
@@ -36346,7 +36901,7 @@ function readOmoDisabledHooks(directory) {
   try {
     for (const dir of getOpenCodeConfigDirs()) {
       for (const name of configNames) {
-        const config = readJsoncFile(join17(dir, name));
+        const config = readJsoncFile(join18(dir, name));
         if (config?.disabled_hooks) {
           for (const hook of config.disabled_hooks) {
             disabled.add(hook);
@@ -36356,17 +36911,17 @@ function readOmoDisabledHooks(directory) {
     }
   } catch {}
   for (const name of configNames) {
-    const config = readJsoncFile(join17(directory, name));
+    const config = readJsoncFile(join18(directory, name));
     if (config?.disabled_hooks) {
       for (const hook of config.disabled_hooks) {
         disabled.add(hook);
       }
     }
   }
-  const homeDir = process.env.HOME || homedir13();
-  const omoHomeDir = join17(homeDir, ".omo");
+  const homeDir = process.env.HOME || homedir14();
+  const omoHomeDir = join18(homeDir, ".omo");
   for (const name of ["omo.jsonc", "omo.json"]) {
-    const config = readJsoncFile(join17(omoHomeDir, name));
+    const config = readJsoncFile(join18(omoHomeDir, name));
     if (config?.["[opencode]"]?.disabled_hooks) {
       for (const hook of config["[opencode]"].disabled_hooks) {
         disabled.add(hook);
@@ -36374,7 +36929,7 @@ function readOmoDisabledHooks(directory) {
     }
   }
   for (const name of ["omo.jsonc", "omo.json"]) {
-    const config = readJsoncFile(join17(directory, ".omo", name));
+    const config = readJsoncFile(join18(directory, ".omo", name));
     if (config?.["[opencode]"]?.disabled_hooks) {
       for (const hook of config["[opencode]"].disabled_hooks) {
         disabled.add(hook);
@@ -36393,9 +36948,9 @@ var init_conflict_detector = __esm(() => {
 });
 
 // ../plugin/src/shared/conflict-fixer.ts
-import { existsSync as existsSync24, readFileSync as readFileSync15, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync16, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import { join as join19 } from "node:path";
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -36403,11 +36958,11 @@ function asStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function readConfig(filePath) {
-  if (!existsSync24(filePath)) {
+  if (!existsSync25(filePath)) {
     return null;
   }
   try {
-    const text = readFileSync15(filePath, "utf-8");
+    const text = readFileSync16(filePath, "utf-8");
     const parsed = import_comment_json5.parse(text);
     return isRecord3(parsed) ? { config: parsed, text } : null;
   } catch {
@@ -36415,27 +36970,27 @@ function readConfig(filePath) {
   }
 }
 function writeConfig(filePath, text) {
-  writeFileSync4(filePath, text);
+  writeFileSync5(filePath, text);
 }
 function resolveUserOpenCodeConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-  if (existsSync24(paths.configJsonc))
+  if (existsSync25(paths.configJsonc))
     return paths.configJsonc;
   return paths.configJson;
 }
 function collectOpenCodeConfigPaths(directory) {
   const paths = new Set;
   const userConfig = resolveUserOpenCodeConfigPath();
-  if (existsSync24(userConfig)) {
+  if (existsSync25(userConfig)) {
     paths.add(userConfig);
   }
   for (const filePath of [
-    join18(directory, ".opencode", "opencode.jsonc"),
-    join18(directory, ".opencode", "opencode.json"),
-    join18(directory, "opencode.jsonc"),
-    join18(directory, "opencode.json")
+    join19(directory, ".opencode", "opencode.jsonc"),
+    join19(directory, ".opencode", "opencode.json"),
+    join19(directory, "opencode.jsonc"),
+    join19(directory, "opencode.json")
   ]) {
-    if (existsSync24(filePath)) {
+    if (existsSync25(filePath)) {
       paths.add(filePath);
     }
   }
@@ -36445,26 +37000,26 @@ function collectOmoConfigPaths(directory) {
   const paths = new Set;
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   for (const fileName of OMO_CONFIG_NAMES) {
-    const userPath = join18(configDir, fileName);
-    const projectPath = join18(directory, fileName);
-    if (existsSync24(userPath)) {
+    const userPath = join19(configDir, fileName);
+    const projectPath = join19(directory, fileName);
+    if (existsSync25(userPath)) {
       paths.add(userPath);
     }
-    if (existsSync24(projectPath)) {
+    if (existsSync25(projectPath)) {
       paths.add(projectPath);
     }
   }
-  const homeDir = process.env.HOME || homedir14();
-  const omoHomeDir = join18(homeDir, ".omo");
+  const homeDir = process.env.HOME || homedir15();
+  const omoHomeDir = join19(homeDir, ".omo");
   for (const name of OMO_UNIFIED_NAMES) {
-    const userPath = join18(omoHomeDir, name);
-    if (existsSync24(userPath)) {
+    const userPath = join19(omoHomeDir, name);
+    if (existsSync25(userPath)) {
       paths.add(userPath);
     }
   }
   for (const name of OMO_UNIFIED_NAMES) {
-    const projectPath = join18(directory, ".omo", name);
-    if (existsSync24(projectPath)) {
+    const projectPath = join19(directory, ".omo", name);
+    if (existsSync25(projectPath)) {
       paths.add(projectPath);
     }
   }
@@ -36592,8 +37147,8 @@ var init_conflict_fixer = __esm(() => {
 });
 
 // src/commands/setup-opencode.ts
-import { existsSync as existsSync25 } from "node:fs";
-import { basename as basename4, dirname as dirname13 } from "node:path";
+import { existsSync as existsSync26 } from "node:fs";
+import { basename as basename4, dirname as dirname14 } from "node:path";
 function resolveCompactionEnabledForWriter() {
   try {
     const config = loadPluginConfig(process.cwd());
@@ -36608,7 +37163,7 @@ function isPlainObject5(value) {
 }
 function planOpenCodeConfigUpdate(configPath, removeDcp = false, compactionEnabled = true, hostGeneration = "v1") {
   const registrationKey = pluginConfigKeyFor(hostGeneration);
-  const existsAtCommit = existsSync25(configPath);
+  const existsAtCommit = existsSync26(configPath);
   const existing = existsAtCommit ? readJsoncConfigForUpdate(configPath) : {};
   if (!existsAtCommit) {
     const created = { [registrationKey]: [OPENCODE_PLUGIN_ENTRY_WITH_VERSION] };
@@ -36623,7 +37178,7 @@ function planOpenCodeConfigUpdate(configPath, removeDcp = false, compactionEnabl
   let changed = false;
   const rawPlugins = readPluginEntries(existing).map(({ entry }) => entry);
   const retainedPlugins = removeDcp ? rawPlugins.filter((plugin) => !matchesPluginEntry(plugin, DCP_PLUGIN_NAME)) : rawPlugins;
-  if (retainedPlugins.some((plugin) => isLocalPathPluginEntry(plugin) && String(plugin).includes("magic-context") && !isDevPathPluginEntry(plugin, dirname13(configPath)))) {
+  if (retainedPlugins.some((plugin) => isLocalPathPluginEntry(plugin) && String(plugin).includes("magic-context") && !isDevPathPluginEntry(plugin, dirname14(configPath)))) {
     log3.warn("An unverifiable local OpenCode plugin path was ignored; its package name is not Magic Context.");
   }
   if (removeDcp) {
@@ -36638,7 +37193,7 @@ function planOpenCodeConfigUpdate(configPath, removeDcp = false, compactionEnabl
     }
   }
   const hasNpmEntry = retainedPlugins.some((plugin) => matchesPluginEntry(plugin, OPENCODE_PLUGIN_NAME));
-  const hasDevEntry = retainedPlugins.some((plugin) => isDevPathPluginEntry(plugin, dirname13(configPath)));
+  const hasDevEntry = retainedPlugins.some((plugin) => isDevPathPluginEntry(plugin, dirname14(configPath)));
   if (!hasNpmEntry && !hasDevEntry) {
     text = Array.isArray(existing[registrationKey]) ? appendJsoncArrayValues(text, [registrationKey], [OPENCODE_PLUGIN_ENTRY_WITH_VERSION]) : setJsoncValue(text, [registrationKey], [OPENCODE_PLUGIN_ENTRY_WITH_VERSION]);
     changed = true;
@@ -36664,18 +37219,18 @@ function planOpenCodeConfigUpdate(configPath, removeDcp = false, compactionEnabl
   return changed ? document.bom + text : null;
 }
 function planTuiConfigUpdate(configPath) {
-  const existsAtCommit = existsSync25(configPath);
+  const existsAtCommit = existsSync26(configPath);
   const existing = existsAtCommit ? readJsoncConfigForUpdate(configPath) : {};
   if (!existsAtCommit) {
     return `${import_comment_json6.stringify({ plugin: [OPENCODE_PLUGIN_ENTRY_WITH_VERSION] }, null, 2)}
 `;
   }
   const rawPlugins = Array.isArray(existing.plugin) ? existing.plugin : [];
-  if (rawPlugins.some((plugin) => isLocalPathPluginEntry(plugin) && String(plugin).includes("magic-context") && !isDevPathPluginEntry(plugin, dirname13(configPath)))) {
+  if (rawPlugins.some((plugin) => isLocalPathPluginEntry(plugin) && String(plugin).includes("magic-context") && !isDevPathPluginEntry(plugin, dirname14(configPath)))) {
     log3.warn("An unverifiable local TUI plugin path was ignored; its package name is not Magic Context.");
   }
   const hasNpmEntry = rawPlugins.some((plugin) => matchesPluginEntry(plugin, OPENCODE_PLUGIN_NAME));
-  const hasDevEntry = rawPlugins.some((plugin) => isDevPathPluginEntry(plugin, dirname13(configPath)));
+  const hasDevEntry = rawPlugins.some((plugin) => isDevPathPluginEntry(plugin, dirname14(configPath)));
   if (hasNpmEntry || hasDevEntry)
     return null;
   const document = readJsoncTextForEdit(configPath);
@@ -36791,7 +37346,7 @@ async function runSetup3(dryRun = false) {
     log3.warn("You can configure models manually in magic-context.jsonc later");
   }
   const paths = detectConfigPaths();
-  const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync25(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
+  const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync26(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
   if (!dryRun) {
     try {
       assertJsoncConfigsParseable([
@@ -37031,6 +37586,8 @@ async function runSetup4(argv) {
     outro2("Setup finished with warnings — see above.");
     return 1;
   }
+  if (!dryRun)
+    await offerDashboardInstall(argv);
   outro2(dryRun ? "Dry run done — no changes were made." : "Done.");
   return 0;
 }
@@ -37069,6 +37626,7 @@ function printNextSteps(adapter) {
   }
 }
 var init_setup = __esm(async () => {
+  init_dashboard_install();
   init_docs_proposal_gitignore();
   init_prompts();
   init_setup_omp();
@@ -37080,26 +37638,55 @@ var init_setup = __esm(async () => {
   ]);
 });
 
+// src/lib/disk-space.ts
+import { existsSync as existsSync27, statfsSync, statSync as statSync13 } from "node:fs";
+import { dirname as dirname15, resolve as resolve9 } from "node:path";
+function availableDiskBytes(path) {
+  const filesystem = statfsSync(path);
+  return filesystem.bavail * filesystem.bsize;
+}
+function checkDiskSpace(path, bytes, freeBytes) {
+  const requiredBytes = Math.ceil(bytes * 1.1);
+  const availableBytes = freeBytes(path);
+  return {
+    requiredBytes,
+    availableBytes,
+    sufficient: availableBytes >= requiredBytes
+  };
+}
+function existingDirectoryAncestor(path) {
+  let current = resolve9(path);
+  for (;; ) {
+    if (existsSync27(current) && statSync13(current).isDirectory())
+      return current;
+    const parent = dirname15(current);
+    if (parent === current)
+      throw new Error(`No existing directory for ${path}`);
+    current = parent;
+  }
+}
+var init_disk_space = () => {};
+
 // ../plugin/src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir15, platform } from "node:os";
-import { join as join19 } from "node:path";
+import { homedir as homedir16, platform } from "node:os";
+import { join as join20 } from "node:path";
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join19(process.env.LOCALAPPDATA ?? homedir15(), "opencode");
+    return join20(process.env.LOCALAPPDATA ?? homedir16(), "opencode");
   }
-  return join19(homedir15(), ".cache", "opencode");
+  return join20(homedir16(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join19(process.env.APPDATA ?? join19(homedir15(), "AppData", "Roaming"), "opencode");
+    return join20(process.env.APPDATA ?? join20(homedir16(), "AppData", "Roaming"), "opencode");
   }
-  return join19(process.env.XDG_CONFIG_HOME ?? join19(homedir15(), ".config"), "opencode");
+  return join20(process.env.XDG_CONFIG_HOME ?? join20(homedir16(), ".config"), "opencode");
 }
 var PACKAGE_NAME = "@cortexkit/opencode-magic-context", CACHE_DIR, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC;
 var init_constants2 = __esm(() => {
-  CACHE_DIR = join19(getOpenCodeCacheRoot(), "packages");
-  USER_OPENCODE_CONFIG = join19(getOpenCodeConfigRoot(), "opencode.json");
-  USER_OPENCODE_CONFIG_JSONC = join19(getOpenCodeConfigRoot(), "opencode.jsonc");
+  CACHE_DIR = join20(getOpenCodeCacheRoot(), "packages");
+  USER_OPENCODE_CONFIG = join20(getOpenCodeConfigRoot(), "opencode.json");
+  USER_OPENCODE_CONFIG_JSONC = join20(getOpenCodeConfigRoot(), "opencode.jsonc");
 });
 
 // ../plugin/src/hooks/auto-update-checker/types.ts
@@ -37122,15 +37709,15 @@ var init_types = __esm(() => {
 
 // ../plugin/src/hooks/auto-update-checker/checker.ts
 import {
-  accessSync as accessSync2,
-  existsSync as existsSync26,
+  accessSync as accessSync3,
+  existsSync as existsSync28,
   constants as fsConstants,
-  readFileSync as readFileSync16,
-  renameSync as renameSync4,
-  statSync as statSync12,
-  writeFileSync as writeFileSync5
+  readFileSync as readFileSync17,
+  renameSync as renameSync5,
+  statSync as statSync14,
+  writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname14, isAbsolute as isAbsolute7, join as join20, resolve as resolve9 } from "node:path";
+import { dirname as dirname16, isAbsolute as isAbsolute7, join as join21, resolve as resolve10 } from "node:path";
 function warn(message) {
   log(`WARN: ${message}`);
 }
@@ -37156,17 +37743,17 @@ function parseJsonConfig(content) {
 }
 function getSurfaceConfigPaths(directory, surface) {
   const name = surface === "server" ? "opencode" : "tui";
-  const globalDir = dirname14(USER_OPENCODE_CONFIG);
+  const globalDir = dirname16(USER_OPENCODE_CONFIG);
   const dirs = [
     globalDir,
     directory,
-    join20(directory, ".opencode"),
+    join21(directory, ".opencode"),
     process.env.OPENCODE_CONFIG_DIR
   ].filter((value) => Boolean(value));
   const paths = [];
   for (const dir of dirs) {
     for (const extension of ["json", "jsonc"]) {
-      const path = join20(dir, `${name}.${extension}`);
+      const path = join21(dir, `${name}.${extension}`);
       if (!paths.includes(path))
         paths.push(path);
     }
@@ -37177,9 +37764,9 @@ function getWinningConfig(directory, surface) {
   let winner = null;
   for (const path of getSurfaceConfigPaths(directory, surface)) {
     try {
-      if (!existsSync26(path))
+      if (!existsSync28(path))
         continue;
-      const parsed = parseJsonConfig(readFileSync16(path, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync17(path, "utf-8"));
       const entries = getPluginEntries(parsed);
       if (entries.some((entry) => entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))) {
         if (winner) {
@@ -37215,14 +37802,14 @@ var init_checker = __esm(() => {
 });
 
 // src/lib/opencode-plugin-schema-fence.ts
-import { existsSync as existsSync27, readdirSync as readdirSync6, readFileSync as readFileSync17 } from "node:fs";
-import { join as join21 } from "node:path";
-import { gunzipSync } from "node:zlib";
+import { existsSync as existsSync29, readdirSync as readdirSync6, readFileSync as readFileSync18 } from "node:fs";
+import { join as join22 } from "node:path";
+import { gunzipSync as gunzipSync2 } from "node:zlib";
 function readPackageVersion(packageJsonPath) {
   try {
-    if (!existsSync27(packageJsonPath))
+    if (!existsSync29(packageJsonPath))
       return null;
-    const packageJson = JSON.parse(readFileSync17(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync18(packageJsonPath, "utf-8"));
     if (packageJson.name !== OPENCODE_PLUGIN_NAME || typeof packageJson.version !== "string") {
       return null;
     }
@@ -37241,8 +37828,8 @@ function readFenceValue(text) {
   return values.size === 1 ? [...values][0] ?? null : null;
 }
 function readFenceFromDist(packageDirectory) {
-  const distDirectory = join21(packageDirectory, "dist");
-  if (!existsSync27(distDirectory))
+  const distDirectory = join22(packageDirectory, "dist");
+  if (!existsSync29(distDirectory))
     return null;
   const pending = [distDirectory];
   const fenceValues = new Set;
@@ -37252,14 +37839,14 @@ function readFenceFromDist(packageDirectory) {
       continue;
     try {
       for (const entry of readdirSync6(directory, { withFileTypes: true })) {
-        const path = join21(directory, entry.name);
+        const path = join22(directory, entry.name);
         if (entry.isDirectory()) {
           pending.push(path);
           continue;
         }
         if (!entry.isFile() || !/\.(?:[cm]?js|ts)$/.test(entry.name))
           continue;
-        const fence = readFenceValue(readFileSync17(path, "utf-8"));
+        const fence = readFenceValue(readFileSync18(path, "utf-8"));
         if (fence !== null)
           fenceValues.add(fence);
       }
@@ -37270,20 +37857,20 @@ function readFenceFromDist(packageDirectory) {
   return fenceValues.size === 1 ? [...fenceValues][0] ?? null : null;
 }
 function findInstalledPluginPackage(cacheDirectory, specifier, requestedVersion) {
-  const directCacheRoot = join21(cacheDirectory, specifier);
+  const directCacheRoot = join22(cacheDirectory, specifier);
   const candidates = [directCacheRoot];
   try {
     for (const entry of readdirSync6(cacheDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const candidate = join21(cacheDirectory, entry.name);
+      const candidate = join22(cacheDirectory, entry.name);
       if (!candidates.includes(candidate))
         candidates.push(candidate);
     }
   } catch {}
   for (const cacheRoot of candidates) {
-    const directory = join21(cacheRoot, "node_modules", ...PACKAGE_PATH_SEGMENTS);
-    const version = readPackageVersion(join21(directory, "package.json"));
+    const directory = join22(cacheRoot, "node_modules", ...PACKAGE_PATH_SEGMENTS);
+    const version = readPackageVersion(join22(directory, "package.json"));
     if (!version)
       continue;
     if (cacheRoot === directCacheRoot || EXACT_VERSION_PATTERN.test(requestedVersion) && version === requestedVersion) {
@@ -37309,7 +37896,7 @@ function readTarOctal(bytes, offset, length) {
 function readFenceFromNpmTarball(tarball) {
   let archive;
   try {
-    archive = gunzipSync(tarball);
+    archive = gunzipSync2(tarball);
   } catch {
     return null;
   }
@@ -37428,13 +38015,13 @@ var init_opencode_plugin_schema_fence = __esm(() => {
 });
 
 // src/commands/doctor-opencode-cache.ts
-import { existsSync as existsSync28, readFileSync as readFileSync18, rmSync as rmSync6 } from "node:fs";
+import { existsSync as existsSync30, readFileSync as readFileSync19, rmSync as rmSync7 } from "node:fs";
 function readCachedPluginVersion(pluginCacheDir) {
   try {
     const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
-    if (!existsSync28(installedPkgPath))
+    if (!existsSync30(installedPkgPath))
       return;
-    const pkg = JSON.parse(readFileSync18(installedPkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync19(installedPkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -37459,9 +38046,9 @@ function readOpenCodePluginConfigUse(config, configDir) {
   return use;
 }
 async function clearPluginCache(options = {}, deps = {}) {
-  const remove = deps.remove ?? ((path) => rmSync6(path, { recursive: true, force: true }));
+  const remove = deps.remove ?? ((path) => rmSync7(path, { recursive: true, force: true }));
   const pluginCacheRoots = getOpenCodePluginCacheRoots();
-  const existingRoots = pluginCacheRoots.filter((root) => existsSync28(root));
+  const existingRoots = pluginCacheRoots.filter((root) => existsSync30(root));
   if (existingRoots.length === 0) {
     return { action: "not_found", path: pluginCacheRoots[0] ?? "" };
   }
@@ -37558,8 +38145,8 @@ var init_doctor_opencode_cache = __esm(async () => {
 });
 
 // src/commands/doctor-cached-plugin-fence.ts
-import { existsSync as existsSync29 } from "node:fs";
-import { dirname as dirname15 } from "node:path";
+import { existsSync as existsSync31 } from "node:fs";
+import { dirname as dirname17 } from "node:path";
 function isReferenced(sources, host, spec) {
   const specs = sources.referencedSpecs?.[host];
   return specs === undefined || specs.has(spec);
@@ -37569,13 +38156,13 @@ function listCachedOpenCodePluginFences(sources = {}) {
   const v1Referenced = isReferenced(sources, "opencode1", "latest");
   for (const root of v1Referenced ? sources.openCodeV1Roots ?? getOpenCodePluginCacheRoots() : []) {
     const packageJson = getOpenCodePluginPackageJsonPath(root);
-    if (!existsSync29(packageJson))
+    if (!existsSync31(packageJson))
       continue;
     fences.push({
       host: "opencode1",
       directory: root,
       version: readCachedPluginVersion(root),
-      supportedVersion: readFenceFromDist(dirname15(packageJson))
+      supportedVersion: readFenceFromDist(dirname17(packageJson))
     });
   }
   for (const slot of listOpenCodeV2PluginCacheSlots(sources.openCodeV2NpmCacheDir)) {
@@ -37591,7 +38178,7 @@ function listCachedOpenCodePluginFences(sources = {}) {
       directory: slot.slot,
       spec: slot.spec,
       version: slot.version,
-      supportedVersion: readFenceFromDist(dirname15(getOpenCodePluginPackageJsonPath(generation)))
+      supportedVersion: readFenceFromDist(dirname17(getOpenCodePluginPackageJsonPath(generation)))
     });
   }
   return fences;
@@ -37774,13 +38361,13 @@ var init_doctor_prune_discovery = __esm(async () => {
 
 // src/commands/doctor-storage-holders.ts
 import { execFileSync as execFileSync5 } from "node:child_process";
-import { readFileSync as readFileSync19, realpathSync as realpathSync4 } from "node:fs";
-import { join as join22, resolve as resolve10 } from "node:path";
+import { readFileSync as readFileSync20, realpathSync as realpathSync4 } from "node:fs";
+import { join as join23, resolve as resolve11 } from "node:path";
 function canonicalStoragePath(path) {
   try {
     return realpathSync4(path);
   } catch {
-    return resolve10(path);
+    return resolve11(path);
   }
 }
 function textReferencesStorage(text, storageDir) {
@@ -37792,7 +38379,7 @@ function textReferencesStorage(text, storageDir) {
       continue;
     if (canonicalStoragePath(value) === target)
       return true;
-    if (token.startsWith("XDG_DATA_HOME=") && canonicalStoragePath(join22(value, "cortexkit", "magic-context")) === target)
+    if (token.startsWith("XDG_DATA_HOME=") && canonicalStoragePath(join23(value, "cortexkit", "magic-context")) === target)
       return true;
   }
   return false;
@@ -37802,7 +38389,7 @@ function processReferencesStorage(pid, storageDir) {
   if (process.platform === "linux") {
     for (const name of ["cmdline", "environ"]) {
       try {
-        texts.push(readFileSync19(`/proc/${pid}/${name}`, "utf8"));
+        texts.push(readFileSync20(`/proc/${pid}/${name}`, "utf8"));
       } catch {}
     }
   } else {
@@ -37824,12 +38411,12 @@ var init_doctor_storage_holders = () => {};
 
 // src/commands/doctor-repair-db.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync30, openSync as openSync4, renameSync as renameSync5, rmSync as rmSync7 } from "node:fs";
-import { homedir as homedir16 } from "node:os";
-import { dirname as dirname16, join as join23 } from "node:path";
+import { closeSync as closeSync4, existsSync as existsSync32, openSync as openSync4, renameSync as renameSync6, rmSync as rmSync8, statSync as statSync15 } from "node:fs";
+import { homedir as homedir17 } from "node:os";
+import { dirname as dirname18, join as join24 } from "node:path";
 function defaultInspectHolders(storageDir, overrides = {}) {
   const deps = {
-    defaultStorageDir: join23(homedir16(), ".local", "share", "cortexkit", "magic-context"),
+    defaultStorageDir: join24(homedir17(), ".local", "share", "cortexkit", "magic-context"),
     inspectRpc: inspectRpcServerDiscovery,
     inspectPi: inspectLivePiProcesses,
     probeFiles: probeHostProcessesUsing,
@@ -37846,7 +38433,7 @@ function defaultInspectHolders(storageDir, overrides = {}) {
     return {
       safe: false,
       blockers: [],
-      uncertainty: `RPC discovery ${rpc.unreadableFile ?? join23(storageDir, "rpc")} ${arm}`
+      uncertainty: `RPC discovery ${rpc.unreadableFile ?? join24(storageDir, "rpc")} ${arm}`
     };
   }
   const blockers = rpc.state === "live" ? rpc.serverPids.map((pid) => `OpenCode server (PID ${pid})`) : [];
@@ -37859,7 +38446,7 @@ function defaultInspectHolders(storageDir, overrides = {}) {
   const pi = overrides.inspectPi ? deps.inspectPi() : processes?.pi ?? deps.inspectPi();
   if (canonicalStoragePath(storageDir) !== canonicalStoragePath(deps.defaultStorageDir)) {
     const holders = deps.probeFiles({
-      files: ["context.db", "store.db"].flatMap((name) => DATABASE_SUFFIXES.map((suffix) => join23(storageDir, `${name}${suffix}`))),
+      files: ["context.db", "store.db"].flatMap((name) => DATABASE_SUFFIXES.map((suffix) => join24(storageDir, `${name}${suffix}`))),
       directories: []
     });
     if (holders.status === "unknown") {
@@ -37892,11 +38479,11 @@ function timestamp(date) {
   return date.toISOString().replaceAll("-", "").replaceAll(":", "").replace(".", "");
 }
 function uniqueBase(preferred) {
-  if (!DATABASE_SUFFIXES.some((suffix) => existsSync30(`${preferred}${suffix}`)))
+  if (!DATABASE_SUFFIXES.some((suffix) => existsSync32(`${preferred}${suffix}`)))
     return preferred;
   for (let attempt = 1;attempt < 1e4; attempt++) {
     const candidate = `${preferred}-${attempt}`;
-    if (!DATABASE_SUFFIXES.some((suffix) => existsSync30(`${candidate}${suffix}`)))
+    if (!DATABASE_SUFFIXES.some((suffix) => existsSync32(`${candidate}${suffix}`)))
       return candidate;
   }
   throw new Error(`Could not allocate a unique recovery path beside ${preferred}`);
@@ -37906,14 +38493,23 @@ function copyBackupBundle(dbPath, stamp) {
   const copiedPaths = copyDatabaseBundle(dbPath, basePath);
   return { basePath, copiedPaths };
 }
-function copyDatabaseBundle(sourceBase, destinationBase) {
+function databaseBundleSizeBytes(sourceBase) {
+  let size = 0;
+  for (const suffix of DATABASE_SUFFIXES) {
+    const source = `${sourceBase}${suffix}`;
+    if (existsSync32(source))
+      size += statSync15(source).size;
+  }
+  return size;
+}
+function copyDatabaseBundle(sourceBase, destinationBase, forcePrivate = false) {
   const copiedPaths = [];
   for (const suffix of DATABASE_SUFFIXES) {
     const source = `${sourceBase}${suffix}`;
-    if (!existsSync30(source))
+    if (!existsSync32(source))
       continue;
     const destination = `${destinationBase}${suffix}`;
-    copyStorageFileSync(source, destination);
+    copyStorageFileSync(source, destination, forcePrivate);
     copiedPaths.push(destination);
   }
   return copiedPaths;
@@ -38026,7 +38622,7 @@ function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath)
   } finally {
     if (dumpWriteFd !== null)
       closeSync4(dumpWriteFd);
-    rmSync7(dumpPath, { force: true });
+    rmSync8(dumpPath, { force: true });
   }
 }
 function schemaMigrationWarning(schemaVersionBefore, fences) {
@@ -38125,25 +38721,25 @@ function prepareFreshDatabase(path) {
 }
 function removeRecoveryBundle(basePath) {
   for (const suffix of DATABASE_SUFFIXES)
-    rmSync7(`${basePath}${suffix}`, { force: true });
+    rmSync8(`${basePath}${suffix}`, { force: true });
 }
 function activateReplacement(dbPath, replacementPath, originalAsidePath) {
   const movedOriginals = [];
   try {
     for (const suffix of DATABASE_SUFFIXES) {
       const from = `${dbPath}${suffix}`;
-      if (!existsSync30(from))
+      if (!existsSync32(from))
         continue;
       const to = `${originalAsidePath}${suffix}`;
-      renameSync5(from, to);
+      renameSync6(from, to);
       movedOriginals.push({ from, to });
     }
-    renameSync5(replacementPath, dbPath);
+    renameSync6(replacementPath, dbPath);
     return movedOriginals.map(({ to }) => to);
   } catch (error) {
     for (const moved of movedOriginals.reverse()) {
-      if (existsSync30(moved.to) && !existsSync30(moved.from))
-        renameSync5(moved.to, moved.from);
+      if (existsSync32(moved.to) && !existsSync32(moved.from))
+        renameSync6(moved.to, moved.from);
     }
     throw error;
   }
@@ -38173,12 +38769,12 @@ function printHelp() {
 async function runRepairDb(options = {}) {
   const prompts = options.prompts ?? promptIO;
   const deps = { ...DEFAULT_DEPS3, ...options.deps };
-  const storageDir = options.storageDir ?? dirname16(options.dbPath ?? join23(getMagicContextStorageDir(), "context.db"));
-  const dbPath = options.dbPath ?? join23(storageDir, "context.db");
+  const storageDir = options.storageDir ?? dirname18(options.dbPath ?? join24(getMagicContextStorageDir(), "context.db"));
+  const dbPath = options.dbPath ?? join24(storageDir, "context.db");
   const stamp = timestamp(deps.now());
   prompts.intro("Magic Context — Repair shared database");
   prompts.log.info(`Database: ${dbPath}`);
-  if (!existsSync30(dbPath)) {
+  if (!existsSync32(dbPath)) {
     prompts.log.error(`Database not found: ${dbPath}`);
     prompts.log.info("Backup: not created (database does not exist)");
     prompts.outro("Database repair failed");
@@ -38388,13 +38984,13 @@ var init_doctor_repair_db = __esm(async () => {
 
 // src/commands/doctor-single-store-repair.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync31, statfsSync, statSync as statSync13 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
-import { dirname as dirname17, join as join24, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync33, statfsSync as statfsSync2, statSync as statSync16 } from "node:fs";
+import { homedir as homedir18 } from "node:os";
+import { dirname as dirname19, join as join25, resolve as resolve12 } from "node:path";
 function existingAncestor(path) {
-  let current = resolve11(path);
-  while (!existsSync31(current))
-    current = dirname17(current);
+  let current = resolve12(path);
+  while (!existsSync33(current))
+    current = dirname19(current);
   return current;
 }
 function describe2(plan, print) {
@@ -38417,7 +39013,7 @@ function runDoctorSingleStoreRepair(options, overrides = {}) {
     inspectHolders: defaultInspectHolders,
     lsofSpawn: spawnSync5,
     freeBytes: (path) => {
-      const fs = statfsSync(path);
+      const fs = statfsSync2(path);
       return fs.bavail * fs.bsize;
     },
     print: console.log,
@@ -38429,15 +39025,15 @@ function runDoctorSingleStoreRepair(options, overrides = {}) {
   };
   try {
     const { dbPath: context, dbDir: data } = resolveDatabasePath();
-    const store = join24(data, "store.db");
-    if (!existsSync31(context) || !existsSync31(store))
+    const store = join25(data, "store.db");
+    if (!existsSync33(context) || !existsSync33(store))
       return refuse("repair_missing_database", `Both ${context} and ${store} must exist.`);
     if (!options.fromBackup)
       return refuse("repair_usage", "--from-backup <dir> is required");
-    const fromBackup = resolve11(options.fromBackup);
+    const fromBackup = resolve12(options.fromBackup);
     for (const name of ["context.db", "store.db"])
-      if (!existsSync31(join24(fromBackup, name)))
-        return refuse("repair_backup_missing", `${join24(fromBackup, name)} does not exist`);
+      if (!existsSync33(join25(fromBackup, name)))
+        return refuse("repair_backup_missing", `${join25(fromBackup, name)} does not exist`);
     const sessions = options.sessions ?? [];
     if (options.live && sessions.length === 0)
       return refuse("repair_usage", "--live repairs named sessions only; pass --session <id>");
@@ -38464,16 +39060,16 @@ function runDoctorSingleStoreRepair(options, overrides = {}) {
 `));
         deps.print(`Repairing while hosts hold the stores (--live): ${blockers.join("; ") || "holders unknown"}`);
       }
-      const backupRoot = resolve11(options.backupRoot ?? join24(data, "backups"));
-      const need = Math.ceil((statSync13(context).size + statSync13(store).size) * 1.1);
+      const backupRoot = resolve12(options.backupRoot ?? join25(data, "backups"));
+      const need = Math.ceil((statSync16(context).size + statSync16(store).size) * 1.1);
       const volume = existingAncestor(backupRoot);
       const have = deps.freeBytes(volume);
       if (have < need)
         return refuse("repair_disk_space", `the backup needs ${need} bytes; have ${have} bytes on ${volume}`);
-      backupDir = join24(backupRoot, `repair-history-${deps.now().toISOString().replaceAll(":", "-")}`);
+      backupDir = join25(backupRoot, `repair-history-${deps.now().toISOString().replaceAll(":", "-")}`);
       deps.print(`Backing up the live stores to ${backupDir} before any write.`);
     }
-    const binary = options.ckMc ?? join24(homedir17(), ".local", "share", "cortexkit", "bin", "ck-mc");
+    const binary = options.ckMc ?? join25(homedir18(), ".local", "share", "cortexkit", "bin", "ck-mc");
     const args = [
       "single-store-repair-history",
       "--context-db",
@@ -38561,28 +39157,22 @@ var init_doctor_single_store_repair = __esm(async () => {
 
 // src/commands/doctor-single-store.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync32, realpathSync as realpathSync5, statfsSync as statfsSync2, statSync as statSync14 } from "node:fs";
-import { homedir as homedir18 } from "node:os";
-import { dirname as dirname18, join as join25, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync34, realpathSync as realpathSync5, statSync as statSync17 } from "node:fs";
+import { homedir as homedir19 } from "node:os";
+import { join as join26, resolve as resolve13 } from "node:path";
 function engineContextPath() {
   const value = (key) => process.env[key]?.trim() || undefined;
   const test = value("MAGIC_CONTEXT_TEST_DATA_DIR");
   const xdg = value("XDG_DATA_HOME");
-  const dir = test ? join25(xdg && xdg !== test ? xdg : test, "cortexkit", "magic-context") : value("MAGIC_CONTEXT_STORAGE_DIR") ?? join25(xdg ?? join25(value("HOME") ?? ".", ".local", "share"), "cortexkit", "magic-context");
-  return join25(dir, "context.db");
-}
-function existingAncestor2(path) {
-  let current = resolve12(path);
-  while (!existsSync32(current))
-    current = dirname18(current);
-  return current;
+  const dir = test ? join26(xdg && xdg !== test ? xdg : test, "cortexkit", "magic-context") : value("MAGIC_CONTEXT_STORAGE_DIR") ?? join26(xdg ?? join26(value("HOME") ?? ".", ".local", "share"), "cortexkit", "magic-context");
+  return join26(dir, "context.db");
 }
 function undo(backup, data, print) {
   const quote = (s) => `'${s.replaceAll("'", "'\\''")}'`;
   print(`Backup: ${backup}`);
   print("To undo: quit every host, then");
-  print(`  rm -f ${["context.db-wal", "context.db-shm", "store.db-wal", "store.db-shm"].map((name) => quote(join25(data, name))).join(" ")}`);
-  print(`  cp ${quote(join25(backup, "context.db"))} ${quote(join25(backup, "store.db"))} ${quote(data + "/")}`);
+  print(`  rm -f ${["context.db-wal", "context.db-shm", "store.db-wal", "store.db-shm"].map((name) => quote(join26(data, name))).join(" ")}`);
+  print(`  cp ${quote(join26(backup, "context.db"))} ${quote(join26(backup, "store.db"))} ${quote(data + "/")}`);
   print("This restores the unmigrated stores. Keep the current plugin and ck-mc: TypeScript mode works as before, and Rust mode will refuse with MC-C14 until you run this command again.");
 }
 function runDoctorSingleStore(options = {}, overrides = {}) {
@@ -38590,10 +39180,7 @@ function runDoctorSingleStore(options = {}, overrides = {}) {
     now: () => new Date,
     inspectHolders: defaultInspectHolders,
     lsofSpawn: spawnSync6,
-    freeBytes: (path) => {
-      const fs = statfsSync2(path);
-      return fs.bavail * fs.bsize;
-    },
+    freeBytes: availableDiskBytes,
     print: console.log,
     ...overrides
   };
@@ -38603,8 +39190,8 @@ function runDoctorSingleStore(options = {}, overrides = {}) {
   };
   try {
     const { dbPath: context, dbDir: data } = resolveDatabasePath();
-    const store = join25(data, "store.db");
-    if (!existsSync32(context) || !existsSync32(store))
+    const store = join26(data, "store.db");
+    if (!existsSync34(context) || !existsSync34(store))
       return refuse("single_store_missing_database", `Both ${context} and ${store} must exist.`);
     const probe = probeHostProcessesUsing({ files: [context, store].flatMap((p) => SUFFIXES2.map((s) => p + s)), directories: [] }, deps.lsofSpawn);
     const holders = deps.inspectHolders(data);
@@ -38619,9 +39206,9 @@ function runDoctorSingleStore(options = {}, overrides = {}) {
       return refuse("single_store_files_in_use", [...lines, STOP].join(`
 `));
     }
-    if (!existsSync32(engineContextPath()) || realpathSync5(context) !== realpathSync5(engineContextPath()))
+    if (!existsSync34(engineContextPath()) || realpathSync5(context) !== realpathSync5(engineContextPath()))
       return refuse("single_store_path_mismatch", `CLI ${context}; engine ${engineContextPath()}`);
-    const backupRoot = resolve12(options.backupRoot ?? join25(data, "backups"));
+    const backupRoot = resolve13(options.backupRoot ?? join26(data, "backups"));
     const contextDb = new Database(context, { readonly: true });
     const storeDb = new Database(store, { readonly: true });
     let contextVersion;
@@ -38648,17 +39235,17 @@ function runDoctorSingleStore(options = {}, overrides = {}) {
     }
     if (contextVersion > LATEST_SUPPORTED_VERSION || storeVersion !== 60)
       return refuse("single_store_version_mismatch", `context.db v${contextVersion}; store.db v${storeVersion}; need context.db v${LATEST_SUPPORTED_VERSION} and store.db v60 (apply current plugin migrations to context.db; upgrade store.db with ck-mc first)`);
-    const backupBytes = statSync14(context).size + statSync14(store).size;
-    const workingBytes = 2 * statSync14(store).size;
-    const backupVolume = existingAncestor2(backupRoot);
-    const sameVolume = statSync14(data).dev === statSync14(backupVolume).dev;
-    const need = Math.ceil((workingBytes + (sameVolume ? backupBytes : 0)) * 1.1);
-    const have = deps.freeBytes(data);
-    if (have < need)
-      return refuse("single_store_disk_space", `need ${need} bytes; have ${have} bytes on ${data}`);
-    if (!sameVolume && deps.freeBytes(backupVolume) < Math.ceil(backupBytes * 1.1))
-      return refuse("single_store_disk_space", `backup needs ${Math.ceil(backupBytes * 1.1)} bytes; have ${deps.freeBytes(backupVolume)} bytes on ${backupVolume}`);
-    const backupDir = join25(backupRoot, `single-store-${deps.now().toISOString().replaceAll(":", "-")}`);
+    const backupBytes = statSync17(context).size + statSync17(store).size;
+    const workingBytes = 2 * statSync17(store).size;
+    const backupVolume = existingDirectoryAncestor(backupRoot);
+    const sameVolume = statSync17(data).dev === statSync17(backupVolume).dev;
+    const dataSpace = checkDiskSpace(data, workingBytes + (sameVolume ? backupBytes : 0), deps.freeBytes);
+    if (!dataSpace.sufficient)
+      return refuse("single_store_disk_space", `need ${dataSpace.requiredBytes} bytes; have ${dataSpace.availableBytes} bytes on ${data}`);
+    const backupSpace = sameVolume ? undefined : checkDiskSpace(backupVolume, backupBytes, deps.freeBytes);
+    if (backupSpace && !backupSpace.sufficient)
+      return refuse("single_store_disk_space", `backup needs ${backupSpace.requiredBytes} bytes; have ${backupSpace.availableBytes} bytes on ${backupVolume}`);
+    const backupDir = join26(backupRoot, `single-store-${deps.now().toISOString().replaceAll(":", "-")}`);
     undo(backupDir, data, deps.print);
     const opened = openDatabase(context);
     if (!opened)
@@ -38670,7 +39257,7 @@ function runDoctorSingleStore(options = {}, overrides = {}) {
     }
     if (contextVersion !== LATEST_SUPPORTED_VERSION)
       return refuse("single_store_version_mismatch", `context.db v${contextVersion}; store.db v${storeVersion}`);
-    const binary = options.ckMc ?? join25(homedir18(), ".local", "share", "cortexkit", "bin", "ck-mc");
+    const binary = options.ckMc ?? join26(homedir19(), ".local", "share", "cortexkit", "bin", "ck-mc");
     const args = [
       "single-store-migrate",
       "--context-db",
@@ -38786,6 +39373,7 @@ function runDoctorSingleStoreCli(args) {
 }
 var STOP = "quit OpenCode, Pi and ck-mc (`ck stop magic-context`) and run again", SUFFIXES2;
 var init_doctor_single_store = __esm(async () => {
+  init_disk_space();
   await __promiseAll([
     init_storage_db(),
     init_sqlite(),
@@ -39160,18 +39748,18 @@ var init_storage_identity_merge = __esm(() => {
 
 // src/commands/doctor-identity-splits.ts
 import { execFileSync as execFileSync6 } from "node:child_process";
-import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync33, readdirSync as readdirSync7, realpathSync as realpathSync6, statSync as statSync15 } from "node:fs";
-import { dirname as dirname19, join as join26, resolve as resolve13 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync35, readdirSync as readdirSync7, realpathSync as realpathSync6, statSync as statSync18 } from "node:fs";
+import { dirname as dirname20, join as join27, resolve as resolve14 } from "node:path";
 function tableExists5(db, table) {
   return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
 }
 function hasGitMetadataInAncestors(directory) {
-  let current = resolve13(directory);
+  let current = resolve14(directory);
   while (true) {
-    if (existsSync33(join26(current, ".git")))
+    if (existsSync35(join27(current, ".git")))
       return true;
-    const parent = dirname19(current);
+    const parent = dirname20(current);
     if (parent === current)
       return false;
     current = parent;
@@ -39180,7 +39768,7 @@ function hasGitMetadataInAncestors(directory) {
 function orphanedPathReason(directory) {
   let entries;
   try {
-    if (!statSync15(directory).isDirectory())
+    if (!statSync18(directory).isDirectory())
       return "path is no longer a directory";
     entries = readdirSync7(directory);
   } catch (error) {
@@ -39255,7 +39843,7 @@ function findIdentitySplits(db, host, includeSingles = false) {
   const gitIdentities = new Map;
   for (const [directoryKey, spellings] of directorySpellings) {
     for (const directory of spellings) {
-      const dirIdentity = `dir:${createHash5("md5").update(resolve13(directory), "utf8").digest("hex").slice(0, 12)}`;
+      const dirIdentity = `dir:${createHash6("md5").update(resolve14(directory), "utf8").digest("hex").slice(0, 12)}`;
       const hasData = [
         "memories",
         "notes",
@@ -39324,7 +39912,7 @@ function identityLines(split) {
   return split.identities.map((row) => `  ${row.identity}: ${row.sessions} sessions, ${row.memories} memories, ${row.notes} notes, ${row.dreamer} dreamer rows (identity-wide counts)`);
 }
 function diagnoseIdentitySplits() {
-  const db = openExistingContextDatabase(join26(getMagicContextStorageDir(), "context.db"), {
+  const db = openExistingContextDatabase(join27(getMagicContextStorageDir(), "context.db"), {
     readonly: true
   });
   if (!db)
@@ -39349,15 +39937,15 @@ var init_doctor_identity_splits = __esm(async () => {
 
 // src/commands/doctor-merge-identity.ts
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync34, mkdtempSync, readdirSync as readdirSync8, readFileSync as readFileSync20 } from "node:fs";
-import { dirname as dirname20, join as join27 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { existsSync as existsSync36, mkdtempSync as mkdtempSync2, readdirSync as readdirSync8, readFileSync as readFileSync21, statSync as statSync19 } from "node:fs";
+import { dirname as dirname21, join as join28, resolve as resolve15 } from "node:path";
 function parseMergeIdentityArgs(args) {
   const values = {};
-  const switches = new Set(["--apply", "--force", "--dry-run", "--yes"]);
+  const switches = new Set(["--apply", "--force", "--dry-run", "--yes", "--verbose"]);
   for (let i = 0;i < args.length; i++) {
     const flag = args[i];
-    if (["--from", "--to", "--db", "--host-db"].includes(flag)) {
+    if (["--from", "--to", "--db", "--host-db", "--backup-root"].includes(flag)) {
       const value = args[++i];
       if (!value || value.startsWith("--"))
         throw new Error(`${flag} requires a value`);
@@ -39377,9 +39965,11 @@ function parseMergeIdentityArgs(args) {
     to: values["--to"],
     dbPath: values["--db"],
     hostPath: values["--host-db"],
+    backupRoot: values["--backup-root"],
     dryRun: !apply,
     yes: apply,
-    force: args.includes("--force")
+    force: args.includes("--force"),
+    verbose: args.includes("--verbose")
   };
 }
 function printReport(report) {
@@ -39399,7 +39989,7 @@ function printReport(report) {
     console.log("  No writes. Review this preview, then repeat with --apply to confirm.");
 }
 function resolveReadOnly(directory) {
-  if (!existsSync34(directory))
+  if (!existsSync36(directory))
     return;
   try {
     const roots = execFileSync7("git", ["rev-list", "--max-parents=0", "HEAD"], {
@@ -39424,14 +40014,23 @@ function resolveReadOnly(directory) {
       return;
   } catch (error) {
     if (String(error.stderr).includes("not a git repository"))
-      return `dir:${createHash6("md5").update(projectDirectoryKey(directory)).digest("hex").slice(0, 12)}`;
+      return `dir:${createHash7("md5").update(projectDirectoryKey(directory)).digest("hex").slice(0, 12)}`;
   }
   return;
 }
 function canonicalIdentity(directory, storageDir) {
   return readRememberedGitIdentity(directory, storageDir) ?? (orphanedPathReason(directory) ? undefined : resolveReadOnly(directory));
 }
+function directoryDoesNotExist(directory) {
+  try {
+    statSync19(directory);
+  } catch (error) {
+    return error.code === "ENOENT";
+  }
+  return false;
+}
 function assertMergePairSafe(db, observed, storageDir, from, to) {
+  const allowances = [];
   if (from.startsWith("git:") && !to.startsWith("git:"))
     throw new Error(`Refusing merge: ${from} is a repository-wide identity shared by every checkout and worktree of its repository. It can only be a merge target, never merged into the directory identity ${to}.`);
   const sourceRows = countIdentityRows(db, from);
@@ -39444,11 +40043,54 @@ function assertMergePairSafe(db, observed, storageDir, from, to) {
     const persisted = readRememberedGitIdentity(row.directory, storageDir);
     if (!persisted)
       continue;
-    if (persisted === from)
+    if (persisted === from) {
+      let live;
+      const orphaned = directoryDoesNotExist(row.directory);
+      if (!orphaned) {
+        try {
+          live = resolveProjectIdentityStrict(row.directory, undefined, { cache: false });
+        } catch {}
+      }
+      if (orphaned || live === to) {
+        allowances.push({
+          directory: row.directory,
+          reason: orphaned ? "orphaned" : `live root now resolves to ${to}`,
+          liveIdentity: live
+        });
+        continue;
+      }
       throw new Error(`Refusing merge: ${from} is the identity the plugin persisted for ${row.directory}; merging away from it would contradict the plugin's own resolution of that path.`);
+    }
     if (persisted !== to)
       throw new Error(`Refusing merge: the plugin persisted ${persisted} for ${row.directory}, where ${involved.map((item) => item.identity).join(" and ")} was observed. That persisted identity is canonical for the path; merge into ${persisted} instead of ${to}.`);
   }
+  return allowances;
+}
+function assertMergeDirectoriesSafe(db, from, to, sourceDirs, targetDirs, allowances) {
+  const alreadyMerged = auditIdentityMerge(db, from, to).changedRows === 0 && db.prepare("SELECT 1 FROM v22_identity_rekey_map WHERE old_project_path = ? AND new_project_path = ?").get(from, to);
+  const allowedDirs = new Set(allowances.map((item) => item.directory));
+  const missingSourceDirs = sourceDirs.filter((directory) => !targetDirs.includes(directory) && directoryDoesNotExist(directory));
+  for (const directory of missingSourceDirs)
+    allowedDirs.add(directory);
+  const sourceDirsAllowed = allowedDirs.size > 0 && sourceDirs.every((directory) => targetDirs.includes(directory) || allowedDirs.has(directory));
+  if (!alreadyMerged && from.startsWith("git:") && to.startsWith("git:") && (!sourceDirs.length || !targetDirs.length || !sourceDirsAllowed && (sourceDirs.some((dir) => !targetDirs.includes(dir)) || targetDirs.some((dir) => !sourceDirs.includes(dir)))))
+    throw new Error(`Refusing different directories for ${from} (${sourceDirs.join(", ") || "unknown"}) and ${to} (${targetDirs.join(", ") || "unknown"})`);
+  return missingSourceDirs;
+}
+function printSidecarPreview(allowances, missingSourceDirs, to, verbose) {
+  const missing = new Set(missingSourceDirs);
+  const orphanPins = allowances.filter((item) => missing.has(item.directory));
+  if (missingSourceDirs.length) {
+    console.log(`  ${missingSourceDirs.length} source-only folders no longer exist: allowed${orphanPins.length ? ` (${orphanPins.length} orphaned sidecar(s) will be rewritten to ${to})` : ""}.${verbose ? "" : " Use --verbose for the full list."}`);
+    if (verbose) {
+      for (const directory of missingSourceDirs)
+        if (!orphanPins.some((item) => item.directory === directory))
+          console.log(`    ${directory} (orphaned; no persisted sidecar)`);
+    }
+  }
+  for (const item of allowances)
+    if (verbose || !missing.has(item.directory))
+      console.log(`  Sidecar for ${item.directory}: overwrite with ${to} (${item.reason}; sidecar will be rewritten).`);
 }
 function printSuggestion(db, split, storageDir) {
   const rows = new Map(split.identities.map((row) => [row.identity, countIdentityRows(db, row.identity)]));
@@ -39503,13 +40145,13 @@ function observations(db, hostPath, storageDir) {
     if (!row.identities.some((item) => item.identity === identity))
       row.identities.push({ identity, sessions: 0, memories: 0, notes: 0, dreamer: 0 });
   };
-  const sidecars = join27(storageDir, "project-identities");
-  if (existsSync34(sidecars))
+  const sidecars = join28(storageDir, "project-identities");
+  if (existsSync36(sidecars))
     for (const file of readdirSync8(sidecars)) {
       if (!file.endsWith(".json"))
         continue;
       try {
-        const record = JSON.parse(readFileSync20(join27(sidecars, file), "utf8"));
+        const record = JSON.parse(readFileSync21(join28(sidecars, file), "utf8"));
         if (typeof record.directory === "string" && typeof record.identity === "string")
           add(record.directory, record.identity);
       } catch {}
@@ -39520,9 +40162,9 @@ function observations(db, hostPath, storageDir) {
 }
 function runMergeIdentityCli(args, deps = {}) {
   const options = parseMergeIdentityArgs(args);
-  const dbPath = options.dbPath ?? join27(getMagicContextStorageDir(), "context.db");
-  const storageDir = dirname20(dbPath);
-  const hostPath = options.hostPath ?? (options.dbPath ? join27(storageDir, "host.db") : resolveOpenCodeDbPath().path);
+  const dbPath = options.dbPath ?? join28(getMagicContextStorageDir(), "context.db");
+  const storageDir = dirname21(dbPath);
+  const hostPath = options.hostPath ?? (options.dbPath ? join28(storageDir, "host.db") : resolveOpenCodeDbPath().path);
   let db = openExistingContextDatabase(dbPath, {
     readonly: true,
     minimumSupportedVersion: CLI_SCHEMA_FLOOR_VERSION
@@ -39542,7 +40184,7 @@ function runMergeIdentityCli(args, deps = {}) {
     }
     if (options.from === options.to)
       throw new Error(`Source and target identities must differ: ${options.from}`);
-    assertMergePairSafe(db, observed, storageDir, options.from, options.to);
+    const allowances = assertMergePairSafe(db, observed, storageDir, options.from, options.to);
     for (const identity of [options.from, options.to]) {
       const known = auditIdentityMerge(db, identity, options.to).changedRows > 0 || db.prepare("SELECT 1 FROM v22_identity_rekey_map WHERE old_project_path = ? OR new_project_path = ?").get(identity, identity);
       if (!known)
@@ -39551,12 +40193,11 @@ function runMergeIdentityCli(args, deps = {}) {
     const sourceDirs = observed.filter((row) => row.identities.some((item) => item.identity === options.from)).map((row) => row.directory);
     const targetDirs = observed.filter((row) => row.identities.some((item) => item.identity === options.to)).map((row) => row.directory);
     directories = [...new Set([...sourceDirs, ...targetDirs])];
-    const alreadyMerged = auditIdentityMerge(db, options.from, options.to).changedRows === 0 && db.prepare("SELECT 1 FROM v22_identity_rekey_map WHERE old_project_path = ? AND new_project_path = ?").get(options.from, options.to);
-    if (!alreadyMerged && options.from.startsWith("git:") && options.to.startsWith("git:") && (!sourceDirs.length || !targetDirs.length || sourceDirs.some((dir) => !targetDirs.includes(dir)) || targetDirs.some((dir) => !sourceDirs.includes(dir))))
-      throw new Error(`Refusing different directories for ${options.from} (${sourceDirs.join(", ") || "unknown"}) and ${options.to} (${targetDirs.join(", ") || "unknown"})`);
-    if (!options.force && !directories.some((directory) => canonicalIdentity(directory, storageDir) === options.to))
+    const missingSourceDirs = assertMergeDirectoriesSafe(db, options.from, options.to, sourceDirs, targetDirs, allowances);
+    if (!options.force && !directories.some((directory) => canonicalIdentity(directory, storageDir) === options.to || allowances.some((item) => item.directory === directory && item.liveIdentity === options.to)))
       throw new Error(`Target ${options.to} does not resolve for any observed directory on this machine; use --force only after reviewing the identity.`);
     const preview = mergeProjectIdentities(db, options.from, options.to, { dryRun: true });
+    printSidecarPreview(allowances, missingSourceDirs, options.to, options.verbose);
     printReport(preview);
     if (options.dryRun)
       return 0;
@@ -39574,47 +40215,64 @@ function runMergeIdentityCli(args, deps = {}) {
   });
   if (!holders.safe || probe.status !== "free")
     throw new Error(`Refusing merge: close OpenCode, Pi, OpenCode 2 and ck-mc. ${holders.blockers.join(", ")} ${holders.uncertainty ?? ""} ${probe.status === "in_use" ? `context.db holders: ${probe.pids.join(", ")}` : probe.status === "unknown" ? probe.reason : ""}`);
-  const backup = mkdtempSync(join27(storageDir, "identity-merge-backup-"));
+  const backupRoot = resolve15(options.backupRoot ?? storageDir);
+  const backupVolume = existingDirectoryAncestor(backupRoot);
+  const sidecarRoot = join28(storageDir, "project-identities");
+  const sidecarEntries = existsSync36(sidecarRoot) ? readdirSync8(sidecarRoot).filter((entry) => entry.endsWith(".json")) : [];
+  const sidecarBytes = sidecarEntries.reduce((size, entry) => size + statSync19(join28(sidecarRoot, entry)).size, 0);
+  const diskSpace = checkDiskSpace(backupVolume, databaseBundleSizeBytes(dbPath) + sidecarBytes, deps.freeBytes ?? availableDiskBytes);
+  if (!diskSpace.sufficient)
+    throw new Error(`merge_identity_disk_space: refusing identity merge: backup needs ${diskSpace.requiredBytes} bytes; have ${diskSpace.availableBytes} bytes on ${backupVolume}. Use --backup-root <dir> to choose a volume with enough free space.`);
+  ensureStorageDirectorySync(backupRoot, true);
+  const backup = mkdtempSync2(join28(backupRoot, "identity-merge-backup-"));
   const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
   console.log(`Backup directory: ${backup}`);
-  console.log(`Restore with hosts closed: rm -f ${quote(`${dbPath}-wal`)} ${quote(`${dbPath}-shm`)}; cp ${quote(join27(backup, "context.db"))} ${quote(dbPath)}; if test -f ${quote(join27(backup, "context.db-wal"))}; then cp ${quote(join27(backup, "context.db-wal"))} ${quote(`${dbPath}-wal`)}; fi`);
-  const sidecarRoot = join27(storageDir, "project-identities");
-  const sidecarBackup = join27(backup, "project-identities");
-  ensureStorageDirectorySync(sidecarBackup);
-  if (existsSync34(sidecarRoot)) {
-    for (const entry of readdirSync8(sidecarRoot)) {
-      if (!entry.endsWith(".json"))
-        continue;
-      writeStorageFileAtomicSync(join27(sidecarBackup, entry), readFileSync20(join27(sidecarRoot, entry)));
-    }
+  console.log(`Restore with hosts closed: rm -f ${quote(`${dbPath}-wal`)} ${quote(`${dbPath}-shm`)}; cp ${quote(join28(backup, "context.db"))} ${quote(dbPath)}; if test -f ${quote(join28(backup, "context.db-wal"))}; then cp ${quote(join28(backup, "context.db-wal"))} ${quote(`${dbPath}-wal`)}; fi`);
+  const sidecarBackup = join28(backup, "project-identities");
+  ensureStorageDirectorySync(sidecarBackup, true);
+  let backupBytes = 0;
+  for (const entry of sidecarEntries) {
+    const content = readFileSync21(join28(sidecarRoot, entry));
+    writeStorageFileAtomicSync(join28(sidecarBackup, entry), content, true);
+    backupBytes += content.byteLength;
   }
   console.log(`Restore identity sidecars too: rm -rf ${quote(sidecarRoot)}; cp -R ${quote(sidecarBackup)} ${quote(sidecarRoot)}`);
-  copyDatabaseBundle(dbPath, join27(backup, "context.db"));
+  const copiedDatabaseFiles = copyDatabaseBundle(dbPath, join28(backup, "context.db"), true);
+  backupBytes += copiedDatabaseFiles.reduce((size, path) => size + statSync19(path).size, 0);
   db = openExistingDatabase(dbPath, { readonly: false });
   if (!db)
     throw new Error(`Context database disappeared: ${dbPath}`);
   try {
     configureContextDatabasePragmas(db);
-    assertMergePairSafe(db, observed, storageDir, from, to);
+    observed = observations(db, hostPath, storageDir);
+    const allowances = assertMergePairSafe(db, observed, storageDir, from, to);
+    const sourceDirs = observed.filter((row) => row.identities.some((item) => item.identity === from)).map((row) => row.directory);
+    const targetDirs = observed.filter((row) => row.identities.some((item) => item.identity === to)).map((row) => row.directory);
+    assertMergeDirectoriesSafe(db, from, to, sourceDirs, targetDirs, allowances);
+    directories = [...new Set([...sourceDirs, ...targetDirs])];
     printReport(mergeProjectIdentities(db, from, to));
   } finally {
     db.close();
   }
   if (to.startsWith("git:"))
     for (const directory of directories) {
-      const root = join27(storageDir, "project-identities");
+      const root = join28(storageDir, "project-identities");
       ensureStorageDirectorySync(root);
-      const path = join27(root, `${createHash6("sha256").update(projectDirectoryKey(directory)).digest("hex")}.json`);
+      const path = join28(root, `${createHash7("sha256").update(projectDirectoryKey(directory)).digest("hex")}.json`);
       writeStorageFileAtomicSync(path, JSON.stringify({ directory: projectDirectoryKey(directory), identity: options.to }));
     }
+  console.log(`Backup: ${backup} (${backupBytes} bytes)`);
+  console.log("This backup can be deleted once the merge has been confirmed.");
   return 0;
 }
 var init_doctor_merge_identity = __esm(async () => {
+  init_project_identity();
   init_project_identity_cache();
   init_storage_identity_merge();
   init_data_path();
   init_opencode_db_path();
   init_storage_permissions();
+  init_disk_space();
   await __promiseAll([
     init_database_access(),
     init_doctor_identity_splits(),
@@ -39624,8 +40282,8 @@ var init_doctor_merge_identity = __esm(async () => {
 });
 
 // src/commands/doctor-git-fts-map.ts
-import { existsSync as existsSync35, mkdtempSync as mkdtempSync2, statSync as statSync16 } from "node:fs";
-import { join as join28, resolve as resolve14 } from "node:path";
+import { existsSync as existsSync37, mkdtempSync as mkdtempSync3, statSync as statSync20 } from "node:fs";
+import { join as join29, resolve as resolve16 } from "node:path";
 function inspectGitFtsMap(db) {
   const has = (name) => Boolean(db.prepare("SELECT 1 FROM sqlite_master WHERE name=? AND type='table'").get(name));
   const indexed = has("git_commits_fts");
@@ -39678,8 +40336,8 @@ function runDoctorGitFtsMap(options = {}, overrides = {}) {
     verify: verifyInventory,
     ...overrides
   };
-  const context = join28(deps.storageDir, "context.db");
-  const store = join28(deps.storageDir, "store.db");
+  const context = join29(deps.storageDir, "context.db");
+  const store = join29(deps.storageDir, "store.db");
   let db = null, storeDb = null;
   let contextLocked = false, storeLocked = false;
   try {
@@ -39701,9 +40359,9 @@ function runDoctorGitFtsMap(options = {}, overrides = {}) {
         deps.print(`Stop every host, then run \`${GIT_FTS_MAP_REPAIR_COMMAND}\`. The repair backs up context.db and store.db first.`);
       return damaged ? 1 : 0;
     }
-    if (!existsSync35(context) || !existsSync35(store))
+    if (!existsSync37(context) || !existsSync37(store))
       throw new Error("Both context.db and store.db must exist before paired-backup repair; no replacement store will be created");
-    const cstat = statSync16(context), sstat = statSync16(store);
+    const cstat = statSync20(context), sstat = statSync20(store);
     if (cstat.dev === sstat.dev && cstat.ino === sstat.ino)
       throw new Error("context.db and store.db must be distinct files");
     const holders = deps.inspectHolders(deps.storageDir);
@@ -39731,12 +40389,12 @@ function runDoctorGitFtsMap(options = {}, overrides = {}) {
     const stillFree = deps.inspectHolders(deps.storageDir);
     if (!stillFree.safe)
       throw new Error(`A host appeared before backup: ${[...stillFree.blockers, stillFree.uncertainty].filter(Boolean).join("; ")}`);
-    const backupRoot = resolve14(options.backupRoot ?? join28(deps.storageDir, "backups"));
+    const backupRoot = resolve16(options.backupRoot ?? join29(deps.storageDir, "backups"));
     ensureStorageDirectorySync(backupRoot, true);
-    const backup = mkdtempSync2(join28(backupRoot, "git-fts-map-"));
-    snapshot(context, join28(backup, "context.db"));
-    snapshot(store, join28(backup, "store.db"));
-    writeStorageFileSync(join28(backup, "manifest.json"), JSON.stringify({
+    const backup = mkdtempSync3(join29(backupRoot, "git-fts-map-"));
+    snapshot(context, join29(backup, "context.db"));
+    snapshot(store, join29(backup, "store.db"));
+    writeStorageFileSync(join29(backup, "manifest.json"), JSON.stringify({
       contextVersion: version,
       createdAt: new Date().toISOString(),
       repair: "git-fts-map",
@@ -39903,20 +40561,20 @@ function assertNoUnmigratedAuthority(db) {
 var SINGLE_STORE_REQUIRED = "Magic Context's Rust mode needs a one-time migration of its store. Quit OpenCode and every ck-mc process, then run `magic-context doctor single-store migrate`. (MC-C14)";
 
 // src/commands/migrate.ts
-import { createHash as createHash7, randomBytes as randomBytes3 } from "node:crypto";
-import { existsSync as existsSync36, mkdirSync as mkdirSync5, renameSync as renameSync6, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname21, join as join29 } from "node:path";
+import { createHash as createHash8, randomBytes as randomBytes3 } from "node:crypto";
+import { existsSync as existsSync38, mkdirSync as mkdirSync6, renameSync as renameSync7, unlinkSync as unlinkSync4 } from "node:fs";
+import { dirname as dirname22, join as join30 } from "node:path";
 function defaultOpenCodeDbPath() {
   return getOpenCodeDatabasePath();
 }
 function defaultCortexkitDbPath() {
-  return join29(getMagicContextStorageDir(), "context.db");
+  return join30(getMagicContextStorageDir(), "context.db");
 }
 function defaultPiSessionsRoot() {
   return getPiSessionsRoot();
 }
 function defaultFs() {
-  return { writeFileAtomic, unlinkSync: unlinkSync4, existsSync: existsSync36, renameSync: renameSync6, mkdirSync: mkdirSync5 };
+  return { writeFileAtomic, unlinkSync: unlinkSync4, existsSync: existsSync38, renameSync: renameSync7, mkdirSync: mkdirSync6 };
 }
 function stmt(db, sql) {
   return db.prepare(sql);
@@ -39943,7 +40601,7 @@ function shortId() {
   return randomBytes3(4).toString("hex");
 }
 function migrationKeyFor(sourceSessionId, targetHarness) {
-  return createHash7("sha256").update(`${sourceSessionId}
+  return createHash8("sha256").update(`${sourceSessionId}
 ${targetHarness}`).digest("hex");
 }
 function hasMigrationJournal(db) {
@@ -39970,7 +40628,7 @@ function sweepPendingMigrations(db, fs = defaultFs()) {
     }
     if (row.phase === "db_committed") {
       if (fs.existsSync(row.stage_path)) {
-        fs.mkdirSync(dirname21(row.final_path), { recursive: true });
+        fs.mkdirSync(dirname22(row.final_path), { recursive: true });
         fs.renameSync(row.stage_path, row.final_path);
         stmt(db, "DELETE FROM migration_pending WHERE migration_key = ?").run(row.migration_key);
         report.rolledForward += 1;
@@ -40000,7 +40658,7 @@ function claimJournalIdentity(args) {
              migration_key, source_session_id, target_harness, pi_session_id,
              final_path, stage_path, content_sha256, phase, created_at
          ) VALUES (?, ?, ?, ?, ?, ?, '', 'staged', ?)
-         ON CONFLICT(migration_key) DO NOTHING`).run(args.migrationKey, args.sourceSessionId, args.targetHarness, piSessionId, args.finalPathFor(piSessionId), join29(args.stageDir, `${args.migrationKey}.jsonl`), args.now);
+         ON CONFLICT(migration_key) DO NOTHING`).run(args.migrationKey, args.sourceSessionId, args.targetHarness, piSessionId, args.finalPathFor(piSessionId), join30(args.stageDir, `${args.migrationKey}.jsonl`), args.now);
   const row = readPendingMigration(args.db, args.migrationKey);
   if (!row) {
     throw new Error("migration journal row disappeared during insert; aborting migration");
@@ -40508,7 +41166,7 @@ function migrateOpenCodeSessionToPi(opts) {
     const provider = opts.provider ?? model.provider;
     const modelId = opts.modelId ?? model.modelId;
     const cwd = session.directory ?? session.path ?? process.cwd();
-    const outputDir = join29(piSessionsRoot, projectPathToPiDirSlug(cwd));
+    const outputDir = join30(piSessionsRoot, projectPathToPiDirSlug(cwd));
     const targetHarness = opts.targetHarness ?? "pi";
     if (cortexkitDb !== null) {
       assertNoUnmigratedAuthority(cortexkitDb);
@@ -40535,8 +41193,8 @@ function migrateOpenCodeSessionToPi(opts) {
         migrationKey,
         sourceSessionId: session.id,
         targetHarness,
-        finalPathFor: (id) => join29(outputDir, `${formatPiFilenameTimestamp(now)}_${id}.jsonl`),
-        stageDir: join29(dirname21(piSessionsRoot), MIGRATION_STAGE_DIRNAME),
+        finalPathFor: (id) => join30(outputDir, `${formatPiFilenameTimestamp(now)}_${id}.jsonl`),
+        stageDir: join30(dirname22(piSessionsRoot), MIGRATION_STAGE_DIRNAME),
         now: now.getTime()
       });
       piSessionId = claimed.row.pi_session_id;
@@ -40545,7 +41203,7 @@ function migrateOpenCodeSessionToPi(opts) {
       journalResumed = claimed.resumed;
     } else {
       piSessionId = generateUuidV7(now);
-      finalPath = join29(outputDir, `${formatPiFilenameTimestamp(now)}_${piSessionId}.jsonl`);
+      finalPath = join30(outputDir, `${formatPiFilenameTimestamp(now)}_${piSessionId}.jsonl`);
       stagePath = "";
     }
     const buildResult = buildPiEntries({
@@ -40584,11 +41242,11 @@ function migrateOpenCodeSessionToPi(opts) {
 `;
     if (!opts.dryRun) {
       if (journalActive && cortexkitDb !== null && migrationKey !== undefined && plan) {
-        const contentSha256 = createHash7("sha256").update(jsonl, "utf8").digest("hex");
+        const contentSha256 = createHash8("sha256").update(jsonl, "utf8").digest("hex");
         commitStagedChecksum(cortexkitDb, migrationKey, contentSha256);
         fs.writeFileAtomic(stagePath, jsonl);
         plan.commit(migrationKey);
-        fs.mkdirSync(dirname21(finalPath), { recursive: true });
+        fs.mkdirSync(dirname22(finalPath), { recursive: true });
         fs.renameSync(stagePath, finalPath);
         stmt(cortexkitDb, "DELETE FROM migration_pending WHERE migration_key = ?").run(migrationKey);
       } else {
@@ -42483,7 +43141,7 @@ var init_dist5 = __esm(() => {
 });
 
 // ../plugin/src/hooks/magic-context/reply-pages.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 function fail() {
   throw Object.assign(new Error("Incomplete or invalid module reply; abandon this pass"), {
     code: "reply_page_invalid"
@@ -42518,7 +43176,7 @@ async function assembleReplyPages(response, fetchPage) {
   if (received !== bytes)
     fail();
   const rebuilt = Buffer.concat(chunks, received);
-  if (createHash8("sha256").update(rebuilt).digest("hex") !== id)
+  if (createHash9("sha256").update(rebuilt).digest("hex") !== id)
     fail();
   return JSON.parse(rebuilt.toString("utf8"));
 }
@@ -42894,9 +43552,9 @@ var init_store_ahead_refusal = __esm(() => {
 
 // ../plugin/src/hooks/magic-context/module-transport.ts
 import { realpathSync as realpathSync7 } from "node:fs";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 function getDefaultSubcConnectionFile() {
-  return join30(getDataDir(), "cortexkit", "run", "subc-connection.json");
+  return join31(getDataDir(), "cortexkit", "run", "subc-connection.json");
 }
 function errorChainSome(error, predicate) {
   let current = error;
@@ -43504,9 +44162,9 @@ var init_module_transport = __esm(() => {
 });
 
 // src/commands/migrate-session.ts
-import { existsSync as existsSync37, realpathSync as realpathSync8 } from "node:fs";
-import { homedir as homedir19 } from "node:os";
-import path6, { join as join31 } from "node:path";
+import { existsSync as existsSync39, realpathSync as realpathSync8 } from "node:fs";
+import { homedir as homedir20 } from "node:os";
+import path6, { join as join32 } from "node:path";
 function existingSessionColumns(db) {
   const rows = db.prepare("PRAGMA table_info(session)").all();
   return new Set(rows.map((r) => r.name).filter((n) => typeof n === "string"));
@@ -43687,14 +44345,14 @@ function defaultOpenCodeDbPath2() {
   return getOpenCodeDatabasePath();
 }
 function defaultContextDbPath() {
-  return join31(getMagicContextStorageDir(), "context.db");
+  return join32(getMagicContextStorageDir(), "context.db");
 }
 function realDeps(opencodeDb, contextDb) {
   return {
     opencodeDb,
     contextDb,
     resolveIdentity: resolveProjectIdentity,
-    hasGitDir: (dir) => existsSync37(join31(dir, ".git")),
+    hasGitDir: (dir) => existsSync39(join32(dir, ".git")),
     realpath: (p) => realpathSync8(p)
   };
 }
@@ -43772,8 +44430,8 @@ async function runMigrateSessionCli(args) {
     printMigrateSessionHelp();
     return 1;
   }
-  const expandedTo = toDir.startsWith("~") ? join31(homedir19(), toDir.slice(1).replace(/^[/\\]/, "")) : toDir;
-  if (!existsSync37(expandedTo)) {
+  const expandedTo = toDir.startsWith("~") ? join32(homedir20(), toDir.slice(1).replace(/^[/\\]/, "")) : toDir;
+  if (!existsSync39(expandedTo)) {
     console.error(`Target directory does not exist: ${expandedTo}`);
     return 1;
   }
@@ -43924,7 +44582,7 @@ var init_migrate_session = __esm(async () => {
 });
 
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import { realpathSync as realpathSync9 } from "node:fs";
 import path7 from "node:path";
 function readMeta(db, key) {
@@ -43973,7 +44631,7 @@ function computeLegacyRustDirIdentity(rawProjectPath) {
   } catch {
     canonical = path7.isAbsolute(rawProjectPath) ? rawProjectPath : path7.join(process.cwd(), rawProjectPath);
   }
-  return `dir:${createHash9("sha256").update(canonical, "utf8").digest("hex")}`;
+  return `dir:${createHash10("sha256").update(canonical, "utf8").digest("hex")}`;
 }
 function upsertRekeyMap(db, oldProjectPath, newProjectPath, rekeyedAt) {
   db.prepare(`INSERT INTO v22_identity_rekey_map (old_project_path, new_project_path, rekeyed_at)
@@ -44194,7 +44852,7 @@ var init_tick_failure = __esm(() => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync38 } from "node:fs";
+import { existsSync as existsSync40 } from "node:fs";
 function getProjectConfigPaths(cwd) {
   const basePath = cortexKitProjectConfigBasePath(cwd);
   return [`${basePath}.jsonc`, `${basePath}.json`];
@@ -44204,10 +44862,10 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path) => existsSync38(path));
+  return paths.find((path) => existsSync40(path));
 }
 function resolvePiLegacyFallback(sources) {
-  return sources.find((source) => existsSync38(source.path)) ?? null;
+  return sources.find((source) => existsSync40(source.path)) ?? null;
 }
 function loadConfigFile(path, scope) {
   let raw;
@@ -44518,7 +45176,7 @@ function loadPiConfigDetailed(opts = {}, applyRuntimeGlobals = true) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync38(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync40(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -44527,7 +45185,7 @@ function loadPiConfigDetailed(opts = {}, applyRuntimeGlobals = true) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync38(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync40(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) {
@@ -44665,7 +45323,7 @@ var DATABASE_REPAIR_COMMAND = "bunx @cortexkit/magic-context@latest doctor repai
 
 // src/lib/github-issue.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { readFileSync as readFileSync21 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 function runGhCommand(args) {
   try {
     const result = spawnSync7("gh", args, {
@@ -44692,7 +45350,7 @@ function failed(result) {
 function submitGithubIssue(title, bodyPath, runner = runGhCommand) {
   let body;
   try {
-    body = readFileSync21(bodyPath, "utf-8");
+    body = readFileSync22(bodyPath, "utf-8");
   } catch (error) {
     return {
       ok: false,
@@ -44750,9 +45408,9 @@ var MAX_GITHUB_ISSUE_BODY_CHARS = 65536;
 var init_github_issue = () => {};
 
 // src/lib/log-lines.ts
-import { existsSync as existsSync39, readFileSync as readFileSync22, statSync as statSync17 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join32 } from "node:path";
+import { existsSync as existsSync41, readFileSync as readFileSync23, statSync as statSync21 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join33 } from "node:path";
 function tokenize(input, limit = Number.POSITIVE_INFINITY) {
   const tokens = [];
   let index = 0;
@@ -45038,20 +45696,20 @@ function parseLogLine(line) {
 }
 function getMagicContextLogPaths(harness, options = {}) {
   const override = options.override === undefined ? process.env.MAGIC_CONTEXT_LOG_PATH?.trim() : options.override?.trim();
-  const storageLogs = join32(options.storageDir ?? getMagicContextStorageDir(), "logs");
+  const storageLogs = join33(options.storageDir ?? getMagicContextStorageDir(), "logs");
   return [
     ...override ? [override] : [],
-    join32(options.tempDir ?? tmpdir2(), harness, "magic-context", "magic-context.log"),
-    join32(storageLogs, `magic-context.${harness}.log`),
-    join32(storageLogs, "magic-context.log")
+    join33(options.tempDir ?? tmpdir3(), harness, "magic-context", "magic-context.log"),
+    join33(storageLogs, `magic-context.${harness}.log`),
+    join33(storageLogs, "magic-context.log")
   ].filter((path, index, paths) => paths.indexOf(path) === index);
 }
 function inspectLogFile(path) {
-  if (!existsSync39(path)) {
+  if (!existsSync41(path)) {
     return { path, exists: false, sizeKb: 0, lineCount: 0, grammar: "unknown" };
   }
   try {
-    const content = readFileSync22(path, "utf8");
+    const content = readFileSync23(path, "utf8");
     const lines = content.split(/\r?\n/).filter((line) => line.length > 0);
     const grammars = new Set(lines.flatMap((line) => {
       const parsed = parseLogLine(line);
@@ -45061,7 +45719,7 @@ function inspectLogFile(path) {
     return {
       path,
       exists: true,
-      sizeKb: Math.round(statSync17(path).size / 1024),
+      sizeKb: Math.round(statSync21(path).size / 1024),
       lineCount: lines.length,
       grammar
     };
@@ -45078,7 +45736,7 @@ function readLogLines(files) {
       return [];
     try {
       let precedingTimestamp = "";
-      return readFileSync22(file.path, "utf8").split(/\r?\n/).filter((line) => line.length > 0).map((line, lineIndex) => {
+      return readFileSync23(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 };
       });
@@ -45273,9 +45931,9 @@ var init_redaction2 = __esm(() => {
 
 // src/commands/doctor-omp.ts
 import { execFileSync as execFileSync8, spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync40, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync42, readFileSync as readFileSync24 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { isAbsolute as isAbsolute8, join as join33, resolve as resolve15 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join34, resolve as resolve17 } 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;
@@ -45317,10 +45975,10 @@ function selfVersion() {
   return "unknown";
 }
 function readConfig2(path) {
-  if (!existsSync40(path))
+  if (!existsSync42(path))
     return {};
   try {
-    const parsed = import_comment_json8.parse(readFileSync23(path, "utf-8"));
+    const parsed = import_comment_json8.parse(readFileSync24(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) };
@@ -45330,7 +45988,7 @@ function pluginDeclaresOmp(path) {
   if (!path)
     return null;
   try {
-    const pkg = JSON.parse(readFileSync23(join33(path, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync24(join34(path, "package.json"), "utf-8"));
     return Array.isArray(pkg.omp?.extensions) || Array.isArray(pkg.pi?.extensions);
   } catch {
     return null;
@@ -45405,8 +46063,8 @@ async function runHealthChecks(options) {
         if (!reportedAgentDir.ok) {
           add(results, "warn", "Could not verify OMP active agent directory");
         } else {
-          const reportedPath = resolve15(reportedAgentDir.stdout);
-          const expectedPath = resolve15(getOmpAgentDir());
+          const reportedPath = resolve17(reportedAgentDir.stdout);
+          const expectedPath = resolve17(getOmpAgentDir());
           if (reportedPath === expectedPath) {
             add(results, "pass", `OMP agent directory resolved to ${getOmpAgentDir()}`);
           } else {
@@ -45417,7 +46075,7 @@ async function runHealthChecks(options) {
     }
   }
   const userConfigPath = getOmpUserConfigPath();
-  if (!existsSync40(userConfigPath)) {
+  if (!existsSync42(userConfigPath)) {
     add(results, "warn", `No Magic Context user config at ${userConfigPath}`);
     repairPlan.writeUserConfig = true;
   } else {
@@ -45434,9 +46092,9 @@ async function runHealthChecks(options) {
     for (const warning of loaded.warnings.slice(0, 5))
       add(results, "warn", warning);
   const storage = getMagicContextStorageResolution();
-  const dbPath = join33(storage.path, "context.db");
+  const dbPath = join34(storage.path, "context.db");
   add(results, "info", `Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync40(dbPath))
+  if (!existsSync42(dbPath))
     add(results, "info", `Shared context DB will be created at ${dbPath}`);
   else {
     let db = null;
@@ -45501,7 +46159,7 @@ function writeDefaultConfig(path) {
 }
 async function repair(plan, deps, prompts, cwd) {
   let fixed = 0;
-  if (plan.writeUserConfig && !existsSync40(getOmpUserConfigPath())) {
+  if (plan.writeUserConfig && !existsSync42(getOmpUserConfigPath())) {
     writeDefaultConfig(getOmpUserConfigPath());
     prompts.log.success(`Wrote default Magic Context config to ${getOmpUserConfigPath()}`);
     fixed += 1;
@@ -45617,7 +46275,7 @@ function runGhCommandWithDeps(deps, args) {
 async function runIssueFlow(options) {
   if (options.reportPath) {
     const report = await runHealthChecks({ ...options, quiet: true });
-    const path = isAbsolute8(options.reportPath) ? options.reportPath : join33(options.cwd, options.reportPath);
+    const path = isAbsolute8(options.reportPath) ? options.reportPath : join34(options.cwd, options.reportPath);
     const bundle = writeOmpIssueReport(path, ompIssueBody("Generated non-interactively by `doctor --issue --report`.", report, readLogLines(report.logFiles), null));
     options.prompts.log.success(bundle.fullPath ? `Sanitized report written to ${bundle.path}; full report at ${bundle.fullPath}` : `Sanitized report written to ${bundle.path}`);
     return 0;
@@ -45644,7 +46302,7 @@ async function runIssueFlow(options) {
     ]);
     sessionFilter = choice === "__all__" ? null : choice;
   }
-  const path = join33(options.cwd, `magic-context-omp-issue-${timestamp2(options.deps.now())}.md`);
+  const path = join34(options.cwd, `magic-context-omp-issue-${timestamp2(options.deps.now())}.md`);
   const bundle = writeOmpIssueReport(path, ompIssueBody(description, report, logLines, sessionFilter));
   options.prompts.log.success(bundle.fullPath ? `Sanitized report written to ${bundle.path}; full report at ${bundle.fullPath}` : `Sanitized report written to ${bundle.path}`);
   if (await options.prompts.confirm("Submit this issue on GitHub now?", false)) {
@@ -45831,7 +46489,7 @@ function truncate2(text) {
 var DEFAULT_TIMEOUT_MS = 1e4, MAX_PREVIEW_CHARS = 240;
 
 // ../plugin/src/features/magic-context/memory/embedding-synapse.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 function toSynapseLaneDescriptor(metadata) {
   const tokenBudget = metadata.recommended_token_budget;
   return {
@@ -45971,7 +46629,7 @@ function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function sha256(value) {
-  return createHash10("sha256").update(value).digest("hex");
+  return createHash11("sha256").update(value).digest("hex");
 }
 function stableJson2(value) {
   if (Array.isArray(value))
@@ -46615,12 +47273,12 @@ function listShadowBackfillStalls(db, projectIdentity) {
 var SHADOW_BACKFILL_PROVENANCE_KEY = "_magicContextShadowBackfill";
 
 // ../plugin/src/shared/auto-update-provenance.ts
-import { existsSync as existsSync41, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync43, readFileSync as readFileSync25 } from "node:fs";
 function readAutoUpdateCheckState(path) {
-  if (!existsSync41(path))
+  if (!existsSync43(path))
     return null;
   try {
-    const value = JSON.parse(readFileSync24(path, "utf-8"));
+    const value = JSON.parse(readFileSync25(path, "utf-8"));
     if (!value || typeof value !== "object" || Array.isArray(value))
       return null;
     const raw = value;
@@ -46647,15 +47305,15 @@ var init_auto_update_provenance = () => {};
 
 // ../plugin/src/shared/tui-config.ts
 import {
-  chmodSync as chmodSync3,
-  existsSync as existsSync42,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync25,
-  renameSync as renameSync7,
-  statSync as statSync18,
-  writeFileSync as writeFileSync6
+  chmodSync as chmodSync4,
+  existsSync as existsSync44,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync26,
+  renameSync as renameSync8,
+  statSync as statSync22,
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname22, join as join34 } from "node:path";
+import { dirname as dirname23, join as join35 } from "node:path";
 function pluginEntryId(entry) {
   if (typeof entry === "string")
     return entry;
@@ -46686,21 +47344,21 @@ function writeTuiConfigAtomic(configPath, config) {
   const body = `${import_comment_json9.stringify(config, null, 2)}
 `;
   const tmpPath = `${configPath}.tmp`;
-  writeFileSync6(tmpPath, body);
+  writeFileSync7(tmpPath, body);
   try {
-    if (statSync18(configPath, { throwIfNoEntry: false })?.isFile()) {
-      chmodSync3(tmpPath, statSync18(configPath).mode & 511);
+    if (statSync22(configPath, { throwIfNoEntry: false })?.isFile()) {
+      chmodSync4(tmpPath, statSync22(configPath).mode & 511);
     }
   } catch {}
-  renameSync7(tmpPath, configPath);
+  renameSync8(tmpPath, configPath);
 }
 function resolveTuiConfigPath(configDirOverride) {
   const configDir = configDirOverride ?? getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join34(configDir, "tui.jsonc");
-  const jsonPath = join34(configDir, "tui.json");
-  if (existsSync42(jsoncPath))
+  const jsoncPath = join35(configDir, "tui.jsonc");
+  const jsonPath = join35(configDir, "tui.json");
+  if (existsSync44(jsoncPath))
     return jsoncPath;
-  if (existsSync42(jsonPath))
+  if (existsSync44(jsonPath))
     return jsonPath;
   return jsoncPath;
 }
@@ -46708,8 +47366,8 @@ function ensureTuiPluginEntry(options = {}) {
   try {
     const configPath = resolveTuiConfigPath(options.configDir);
     let config = {};
-    if (existsSync42(configPath)) {
-      const raw = readFileSync25(configPath, "utf-8");
+    if (existsSync44(configPath)) {
+      const raw = readFileSync26(configPath, "utf-8");
       config = import_comment_json9.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config.plugin) ? [...config.plugin] : [];
@@ -46743,7 +47401,7 @@ function ensureTuiPluginEntry(options = {}) {
       }
     }
     config.plugin = plugins;
-    mkdirSync6(dirname22(configPath), { recursive: true });
+    mkdirSync7(dirname23(configPath), { recursive: true });
     writeTuiConfigAtomic(configPath, config);
     log(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -46761,9 +47419,9 @@ var init_tui_config = __esm(() => {
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync43, readdirSync as readdirSync9, readFileSync as readFileSync26, statSync as statSync19 } from "node:fs";
+import { existsSync as existsSync45, readdirSync as readdirSync9, readFileSync as readFileSync27, statSync as statSync23 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 function getSelfVersion() {
   const require2 = createRequire4(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -46778,7 +47436,7 @@ function getSelfVersion() {
 }
 function readLegacyCachedVersion(root) {
   try {
-    const pkg = JSON.parse(readFileSync26(getOpenCodePluginPackageJsonPath(root), "utf-8"));
+    const pkg = JSON.parse(readFileSync27(getOpenCodePluginPackageJsonPath(root), "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -46787,7 +47445,7 @@ function readLegacyCachedVersion(root) {
 function collectOpenCodePluginCacheReport(hostGeneration, opencodeConfig) {
   const installs = [];
   for (const root of getOpenCodePluginCacheRoots()) {
-    if (!existsSync43(root))
+    if (!existsSync45(root))
       continue;
     const spec = root.endsWith("@latest") ? "latest" : "(bare)";
     installs.push({
@@ -46821,7 +47479,7 @@ function getStorageResolution() {
 }
 function fileSize(path) {
   try {
-    return existsSync43(path) ? statSync19(path).size : 0;
+    return existsSync45(path) ? statSync23(path).size : 0;
   } catch {
     return 0;
   }
@@ -46833,10 +47491,10 @@ function sanitizeValue(value) {
   return sanitizeConfigValue(value);
 }
 function readConfig3(path) {
-  if (!existsSync43(path))
+  if (!existsSync45(path))
     return { value: null };
   try {
-    const raw = readFileSync26(path, "utf-8");
+    const raw = readFileSync27(path, "utf-8");
     const value = import_comment_json10.parse(raw);
     return { value };
   } catch (error) {
@@ -46861,7 +47519,7 @@ function configHasPluginEntry(config) {
 }
 function parseHistorianDumpMeta(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) {
@@ -46894,11 +47552,11 @@ function parseHistorianDumpMeta(path) {
   }
 }
 function listDumpsInDir(dir, limit) {
-  if (!existsSync43(dir))
+  if (!existsSync45(dir))
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync9(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync19(join35(dir, name));
+      const stat = statSync23(join36(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -46907,7 +47565,7 @@ function listDumpsInDir(dir, limit) {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta = parseHistorianDumpMeta(join35(dir, entry.name));
+      const meta = parseHistorianDumpMeta(join36(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -47018,7 +47676,7 @@ function collectRecentSessionsFromDatabase(database) {
   });
 }
 async function collectDatabaseRows(path, read) {
-  if (!existsSync43(path))
+  if (!existsSync45(path))
     return { available: false, reason: "path missing" };
   let backend;
   try {
@@ -47050,7 +47708,7 @@ async function collectRecentSessions(resolution, hostGeneration) {
   });
 }
 async function collectHistorianFailures(storageDirPath) {
-  return collectDatabaseRows(join35(storageDirPath, "context.db"), (db) => {
+  return collectDatabaseRows(join36(storageDirPath, "context.db"), (db) => {
     const rows = db.prepare("SELECT session_id, historian_failure_count, historian_last_error, historian_last_failure_at FROM session_meta WHERE historian_failure_count > 0 ORDER BY historian_last_failure_at DESC LIMIT 10").all();
     return rows.map((row) => {
       const sessionId = typeof row.session_id === "string" ? row.session_id : "<unknown>";
@@ -47063,7 +47721,7 @@ async function collectHistorianFailures(storageDirPath) {
   });
 }
 async function collectHistorianRuns(storageDirPath) {
-  return collectDatabaseRows(join35(storageDirPath, "context.db"), (db) => {
+  return collectDatabaseRows(join36(storageDirPath, "context.db"), (db) => {
     const aggRows = db.prepare(`SELECT session_id,
                     COUNT(*) AS total,
                     SUM(CASE WHEN status='success' THEN 1 ELSE 0 END) AS success,
@@ -47117,7 +47775,7 @@ async function collectDiagnostics() {
   const magicContextConfig = readConfig3(configPaths.magicContextConfig);
   const storageResolution = getStorageResolution();
   const storageDirPath = storageResolution.path;
-  const contextDbPath = join35(storageDirPath, "context.db");
+  const contextDbPath = join36(storageDirPath, "context.db");
   let compactionEnabled = false;
   try {
     compactionEnabled = isCompactionEnabled(loadPluginConfig(process.cwd()));
@@ -47149,7 +47807,7 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync43(configPaths.magicContextConfig),
+      exists: existsSync45(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
@@ -47157,7 +47815,7 @@ async function collectDiagnostics() {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync43(storageDirPath),
+      exists: existsSync45(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     openCodeDatabase: {
@@ -47407,9 +48065,9 @@ var init_embedding_local = __esm(() => {
 
 // src/lib/embedding-runtime.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync44, readFileSync as readFileSync27 } from "node:fs";
+import { existsSync as existsSync46, readFileSync as readFileSync28 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname23, join as join36, sep } from "node:path";
+import { dirname as dirname24, join as join37, sep } from "node:path";
 function describeError(error) {
   const message = error instanceof Error ? error.message : String(error ?? "unknown error");
   const code = error?.code;
@@ -47551,11 +48209,11 @@ function expectedBinaryRelPath(platform, arch) {
   const supportedArch = arch === "x64" || arch === "arm64";
   if (!supportedPlatform || !supportedArch)
     return null;
-  return join36("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
+  return join37("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
 }
 function onnxRuntimeNodeVersion(packageDir) {
   try {
-    const parsed = JSON.parse(readFileSync27(join36(packageDir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync28(join37(packageDir, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : undefined;
   } catch {
     return;
@@ -47604,7 +48262,7 @@ function formatLocalEmbeddingRuntimeWasmSelected(status) {
 function requireNodeWasmBundle(probe, candidates) {
   if (probe.state === "failed")
     return probe;
-  const bundlePath = candidates.find((candidate) => existsSync44(candidate));
+  const bundlePath = candidates.find((candidate) => existsSync46(candidate));
   return bundlePath ? probe : {
     state: "failed",
     reason: `functional Node WASM Transformers bundle is missing (checked ${candidates.join(", ")})`
@@ -47612,13 +48270,13 @@ function requireNodeWasmBundle(probe, candidates) {
 }
 function nodeWasmBundleCandidates(installRoot) {
   return [
-    join36(installRoot, "dist", "transformers-node-wasm.js"),
-    join36(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
-    join36(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
+    join37(installRoot, "dist", "transformers-node-wasm.js"),
+    join37(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
+    join37(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
   ];
 }
 function probeWasmRuntimeAt(installRoot) {
-  const requireFn = createRequire5(join36(installRoot, "package.json"));
+  const requireFn = createRequire5(join37(installRoot, "package.json"));
   return requireNodeWasmBundle(probeWasmRuntimeFromRequire(requireFn), nodeWasmBundleCandidates(installRoot));
 }
 function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
@@ -47627,9 +48285,9 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
     const wasm = probeWasmRuntimeAt(installRoot);
     return wasm.state === "ok" ? { state: "wasm-selected", wasmPath: wasm.wasmPath } : { state: "wasm-broken", wasmReason: wasm.reason };
   }
-  const packageDir = join36(installRoot, "node_modules", "onnxruntime-node");
+  const packageDir = join37(installRoot, "node_modules", "onnxruntime-node");
   let native;
-  if (!existsSync44(join36(packageDir, "package.json"))) {
+  if (!existsSync46(join37(packageDir, "package.json"))) {
     native = { state: "package-missing", packageDir };
   } else {
     const rel = expectedBinaryRelPath(platform, arch);
@@ -47639,8 +48297,8 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
         binaryPath: packageDir
       };
     } else {
-      const binaryPath = join36(packageDir, rel);
-      native = existsSync44(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
+      const binaryPath = join37(packageDir, rel);
+      native = existsSync46(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
         state: "binary-missing",
         packageDir,
         expectedBinary: binaryPath,
@@ -47651,7 +48309,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) => existsSync44(root));
+  const existing = installRoots.filter((root) => existsSync46(root));
   if (existing.length === 0) {
     return {
       state: "unknown",
@@ -47677,19 +48335,19 @@ function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, a
 function packageDirFromResolved(resolvedPath, packageName) {
   const marker = `node_modules${sep}${packageName.split("/").join(sep)}`;
   const idx = resolvedPath.indexOf(marker);
-  return idx >= 0 ? resolvedPath.slice(0, idx + marker.length) : dirname23(resolvedPath);
+  return idx >= 0 ? resolvedPath.slice(0, idx + marker.length) : dirname24(resolvedPath);
 }
 function probeWasmRuntimeByResolution(pluginDir) {
   try {
-    const reqPlugin = createRequire5(join36(pluginDir, "package.json"));
+    const reqPlugin = createRequire5(join37(pluginDir, "package.json"));
     const direct = probeWasmRuntimeFromRequire(reqPlugin);
     let probe = direct;
     if (direct.state === "failed" && direct.reason.startsWith("onnxruntime-web is not resolvable")) {
       const tfResolved = reqPlugin.resolve("@huggingface/transformers");
       const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-      probe = probeWasmRuntimeFromRequire(createRequire5(join36(tfDir, "package.json")));
+      probe = probeWasmRuntimeFromRequire(createRequire5(join37(tfDir, "package.json")));
     }
-    return requireNodeWasmBundle(probe, [join36(pluginDir, "dist", "transformers-node-wasm.js")]);
+    return requireNodeWasmBundle(probe, [join37(pluginDir, "dist", "transformers-node-wasm.js")]);
   } catch (error) {
     return {
       state: "failed",
@@ -47698,7 +48356,7 @@ function probeWasmRuntimeByResolution(pluginDir) {
   }
 }
 function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  if (!existsSync44(join36(pluginDir, "package.json"))) {
+  if (!existsSync46(join37(pluginDir, "package.json"))) {
     return { state: "unknown", reason: "plugin package dir not found" };
   }
   const selectedRuntime = resolveLocalEmbeddingWorkerRuntime(runtimePreference, host);
@@ -47709,13 +48367,13 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   let onnxDir = null;
   let resolveError;
   try {
-    const reqPlugin = createRequire5(join36(pluginDir, "package.json"));
+    const reqPlugin = createRequire5(join37(pluginDir, "package.json"));
     try {
       onnxDir = packageDirFromResolved(reqPlugin.resolve("onnxruntime-node"), "onnxruntime-node");
     } catch {
       const tfResolved = reqPlugin.resolve("@huggingface/transformers");
       const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-      const reqTf = createRequire5(join36(tfDir, "package.json"));
+      const reqTf = createRequire5(join37(tfDir, "package.json"));
       onnxDir = packageDirFromResolved(reqTf.resolve("onnxruntime-node"), "onnxruntime-node");
     }
   } catch (error) {
@@ -47723,7 +48381,7 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
     if (resolveError === "ERR_MODULE_NOT_FOUND" || resolveError === "MODULE_NOT_FOUND") {
       return withWasmFallback({
         state: "package-missing",
-        packageDir: join36(pluginDir, "node_modules", "onnxruntime-node")
+        packageDir: join37(pluginDir, "node_modules", "onnxruntime-node")
       }, () => probeWasmRuntimeByResolution(pluginDir));
     }
     return {
@@ -47739,8 +48397,8 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   if (rel === null) {
     native = probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath: onnxDir };
   } else {
-    const binaryPath = join36(onnxDir, rel);
-    native = existsSync44(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
+    const binaryPath = join37(onnxDir, rel);
+    native = existsSync46(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
       state: "binary-missing",
       packageDir: onnxDir,
       expectedBinary: binaryPath,
@@ -47775,8 +48433,8 @@ var init_embedding_runtime = __esm(() => {
 });
 
 // src/lib/logs-opencode.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname24, join as join37 } from "node:path";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname25, join as join38 } from "node:path";
 function sanitizeLogContent(content) {
   return sanitizeDiagnosticText(content);
 }
@@ -47869,13 +48527,13 @@ async function bundleIssueReport(report, description, title, sessionFilter = nul
   const bodyMarkdown = capBodyToGithubLimit(rawBodyMarkdown);
   const truncated = bodyMarkdown !== rawBodyMarkdown;
   const timestamp = formatTimestamp(new Date);
-  const path = options.outputPath ?? join37(process.cwd(), `magic-context-issue-${timestamp}.md`);
-  mkdirSync7(dirname24(path), { recursive: true });
-  writeFileSync7(path, `${bodyMarkdown}
+  const path = options.outputPath ?? join38(process.cwd(), `magic-context-issue-${timestamp}.md`);
+  mkdirSync8(dirname25(path), { recursive: true });
+  writeFileSync8(path, `${bodyMarkdown}
 `);
-  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join37(process.cwd(), `magic-context-issue-${timestamp}-full.md`) : undefined;
+  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join38(process.cwd(), `magic-context-issue-${timestamp}-full.md`) : undefined;
   if (fullPath)
-    writeFileSync7(fullPath, `${rawBodyMarkdown}
+    writeFileSync8(fullPath, `${rawBodyMarkdown}
 `);
   return { path, bodyMarkdown, ...fullPath ? { fullPath } : {}, truncated };
 }
@@ -48686,10 +49344,10 @@ function removeDeprecatedReasoningAge(config) {
 
 // src/commands/doctor-opencode.ts
 import { spawnSync as spawnSync10 } from "node:child_process";
-import { existsSync as existsSync45, mkdtempSync as mkdtempSync3, readFileSync as readFileSync28, rmSync as rmSync8 } from "node:fs";
+import { existsSync as existsSync47, mkdtempSync as mkdtempSync4, readFileSync as readFileSync29, rmSync as rmSync9 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { homedir as homedir20, tmpdir as tmpdir3 } from "node:os";
-import { dirname as dirname25, join as join38, resolve as resolve16 } from "node:path";
+import { homedir as homedir21, tmpdir as tmpdir4 } from "node:os";
+import { dirname as dirname26, join as join39, resolve as resolve18 } from "node:path";
 function formatSharedDbRowCounts(db) {
   return SHARED_DB_ROW_COUNT_TABLES.map((table) => {
     try {
@@ -48758,7 +49416,7 @@ function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args
   }
   if (models.length === 0)
     return;
-  const tempRoot = mkdtempSync3(join38(tmpdir3(), "magic-context-opencode-catalog-"));
+  const tempRoot = mkdtempSync4(join39(tmpdir4(), "magic-context-opencode-catalog-"));
   try {
     const command = hostGeneration === "v2" ? ["api", "model.list", "--param", `directory=${projectDir}`] : ["models", "--verbose"];
     const guidance = `opencode ${command.join(" ")}`;
@@ -48777,7 +49435,7 @@ function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args
       warn(`${entry.agent} model ${entry.model} requests variant '${entry.variant}', which this host does not offer. Remove the variant or choose one listed by ${guidance}.`);
     }
   } finally {
-    rmSync8(tempRoot, { recursive: true, force: true });
+    rmSync9(tempRoot, { recursive: true, force: true });
   }
 }
 function parseOpenCodeV2ModelCatalog(output) {
@@ -48934,7 +49592,7 @@ function getSelfVersion2() {
 function describeAutoUpdateStall(specifier, autoUpdateEnabled, storageDir = getMagicContextStorageDir()) {
   if (!autoUpdateEnabled || !isPinnedOpenCodePluginSpecifier(specifier))
     return null;
-  const state = readAutoUpdateCheckState(join38(storageDir, AUTO_UPDATE_CHECK_STATE_FILENAME));
+  const state = readAutoUpdateCheckState(join39(storageDir, AUTO_UPDATE_CHECK_STATE_FILENAME));
   const owner = isUpdaterPinnedSpec(state, specifier) ? "updater" : "you";
   return `auto-update: stalled — config pinned to ${specifier} (by ${owner})`;
 }
@@ -48943,15 +49601,15 @@ function getUserNpmrcPath() {
   if (custom)
     return custom;
   const home = process.env.HOME?.trim();
-  return join38(home || homedir20(), ".npmrc");
+  return join39(home || homedir21(), ".npmrc");
 }
 function collectNpmReleaseAgeWarnings() {
   const ageWarnings = [];
   const npmrcPath = getUserNpmrcPath();
-  if (!existsSync45(npmrcPath))
+  if (!existsSync47(npmrcPath))
     return ageWarnings;
   try {
-    const npmrc = readFileSync28(npmrcPath, "utf-8");
+    const npmrc = readFileSync29(npmrcPath, "utf-8");
     for (const line of npmrc.split(`
 `)) {
       const trimmed = line.trim();
@@ -48965,7 +49623,7 @@ function collectNpmReleaseAgeWarnings() {
   } catch {}
   return ageWarnings;
 }
-function compareVersions(a, b) {
+function compareVersions2(a, b) {
   return compareSemverPrecedence(a, b);
 }
 function openBrowser(url) {
@@ -48992,7 +49650,7 @@ async function runIssueFlow2(options = {}, deps = { collectDiagnostics }) {
   if (options.reportPath) {
     try {
       const report = await deps.collectDiagnostics();
-      const bundled = await bundleIssueReport(report, "Generated non-interactively by `doctor --issue --report`.", "Magic Context diagnostic report", null, { outputPath: resolve16(process.cwd(), options.reportPath) });
+      const bundled = await bundleIssueReport(report, "Generated non-interactively by `doctor --issue --report`.", "Magic Context diagnostic report", null, { outputPath: resolve18(process.cwd(), options.reportPath) });
       log3.info(bundled.fullPath ? `Report written to ${bundled.path}; full bundle at ${bundled.fullPath}` : `Report written to ${bundled.path}`);
       return 0;
     } catch (error) {
@@ -49086,7 +49744,7 @@ function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync45(magicContextConfigPath)) {
+  if (!existsSync47(magicContextConfigPath)) {
     return checkLocalEmbeddingRuntimeForDoctor();
   }
   let rawText;
@@ -49244,7 +49902,7 @@ function getOpenCodePluginHostStatus(hostLabel, hostVersion, installed) {
       message: `${hostLabel} found; Magic Context is not installed there (run setup to add it)`
     };
   }
-  if (openCodeHostGenerationFromVersion(hostVersion) === "v2" && compareVersions(hostVersion, "2.0.22") === -1) {
+  if (openCodeHostGenerationFromVersion(hostVersion) === "v2" && compareVersions2(hostVersion, "2.0.22") === -1) {
     return {
       status: "fail",
       message: describeOpenCode2SessionAPIRequirement(hostVersion)
@@ -49261,7 +49919,7 @@ async function runDoctor2(options = {}) {
   const v22Result = await runV22BackfillCommands({
     name: "OpenCode",
     openDatabase: (readonly = true) => {
-      const dbPath = join38(getMagicContextStorageDir(), "context.db");
+      const dbPath = join39(getMagicContextStorageDir(), "context.db");
       v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
       return v22Db;
     },
@@ -49293,7 +49951,7 @@ async function runDoctor2(options = {}) {
     failCount++;
     issues++;
   };
-  const authorityDbPath = join38(getMagicContextStorageDir(), "context.db");
+  const authorityDbPath = join39(getMagicContextStorageDir(), "context.db");
   let authorityDb = null;
   try {
     authorityDb = openExistingContextDatabase(authorityDbPath, { readonly: true });
@@ -49332,8 +49990,8 @@ async function runDoctor2(options = {}) {
   let magicContextStatusKnown = paths.opencodeConfigFormat === "none";
   if (!magicContextStatusKnown) {
     try {
-      const config = import_comment_json11.parse(readFileSync28(paths.opencodeConfig, "utf-8"));
-      magicContextInstalled = isOpenCodePluginRegistered(config, dirname25(paths.opencodeConfig));
+      const config = import_comment_json11.parse(readFileSync29(paths.opencodeConfig, "utf-8"));
+      magicContextInstalled = isOpenCodePluginRegistered(config, dirname26(paths.opencodeConfig));
       magicContextStatusKnown = true;
     } catch {}
   }
@@ -49452,7 +50110,7 @@ async function runDoctor2(options = {}) {
   }
   const selfVersion = getSelfVersion2();
   const npmLatest = await fetchNpmLatest(CLI_PACKAGE_NAME);
-  const cliComparison = npmLatest ? compareVersions(selfVersion, npmLatest) : null;
+  const cliComparison = npmLatest ? compareVersions2(selfVersion, npmLatest) : null;
   if (!npmLatest) {
     log3.info(`Magic Context CLI v${selfVersion}; npm latest check unavailable`);
   } else if (cliComparison === null) {
@@ -49468,7 +50126,7 @@ async function runDoctor2(options = {}) {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
   let autoUpdateEnabled = true;
-  if (existsSync45(paths.magicContextConfig)) {
+  if (existsSync47(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
@@ -49504,7 +50162,7 @@ async function runDoctor2(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log3.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync45(paths.magicContextConfig)) {
+  if (existsSync47(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -49644,10 +50302,10 @@ async function runDoctor2(options = {}) {
   };
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      const raw = readFileSync28(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync29(paths.opencodeConfig, "utf-8");
       const config = import_comment_json11.parse(raw);
       const configName = paths.opencodeConfigFormat === "jsonc" ? "opencode.jsonc" : "opencode.json";
-      const configDir = dirname25(paths.opencodeConfig);
+      const configDir = dirname26(paths.opencodeConfig);
       magicContextInstalled = isOpenCodePluginRegistered(config, configDir);
       magicContextStatusKnown = true;
       if (magicContextInstalled) {
@@ -49737,11 +50395,11 @@ async function runDoctor2(options = {}) {
       pass("Added TUI sidebar plugin to tui.json");
       warn("Restart OpenCode to see the sidebar");
       fixed++;
-    } else if (existsSync45(paths.tuiConfig)) {
+    } else if (existsSync47(paths.tuiConfig)) {
       try {
-        const tuiRaw = readFileSync28(paths.tuiConfig, "utf-8");
+        const tuiRaw = readFileSync29(paths.tuiConfig, "utf-8");
         const tuiConfig = import_comment_json11.parse(tuiRaw);
-        const tuiConfigDir = dirname25(paths.tuiConfig);
+        const tuiConfigDir = dirname26(paths.tuiConfig);
         const tuiRawPlugins = Array.isArray(tuiConfig?.plugin) ? tuiConfig.plugin : [];
         const tuiIdx = tuiRawPlugins.findIndex((entry) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry, tuiConfigDir));
         if (tuiRawPlugins.some((entry) => isLocalPathPluginEntry(entry) && String(entry).includes("magic-context") && !isDevPathPluginEntry(entry, tuiConfigDir))) {
@@ -49778,7 +50436,7 @@ async function runDoctor2(options = {}) {
       fail("Could not create or verify the TUI sidebar config");
     }
   }
-  if (existsSync45(paths.magicContextConfig)) {
+  if (existsSync47(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -49800,9 +50458,9 @@ async function runDoctor2(options = {}) {
   else
     passCount++;
   const storage = getMagicContextStorageResolution();
-  const dbPath = join38(storage.path, "context.db");
+  const dbPath = join39(storage.path, "context.db");
   log3.info(`Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync45(dbPath)) {
+  if (!existsSync47(dbPath)) {
     log3.info(`Shared context DB not yet created at ${dbPath} (will be created on first run)`);
   } else {
     log3.info(`Shared context DB exists at ${dbPath}`);
@@ -49885,7 +50543,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     let pluginConfigUse;
     if (paths.opencodeConfigFormat !== "none") {
       try {
-        pluginConfigUse = readOpenCodePluginConfigUse(import_comment_json11.parse(readFileSync28(paths.opencodeConfig, "utf-8")), dirname25(paths.opencodeConfig));
+        pluginConfigUse = readOpenCodePluginConfigUse(import_comment_json11.parse(readFileSync29(paths.opencodeConfig, "utf-8")), dirname26(paths.opencodeConfig));
       } catch {}
     }
     const cacheResult = await clearPluginCache({
@@ -49937,7 +50595,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     let v2DistTag;
     if (paths.opencodeConfigFormat !== "none") {
       try {
-        v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync28(paths.opencodeConfig, "utf-8")));
+        v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync29(paths.opencodeConfig, "utf-8")));
       } catch {}
     }
     const v2Cache = reportOpenCodeV2PluginCache(checkOpenCodeV2PluginCache({
@@ -50318,9 +50976,9 @@ var init_model_chain_health = __esm(() => {
 });
 
 // src/lib/diagnostics-pi.ts
-import { existsSync as existsSync46, readdirSync as readdirSync10, readFileSync as readFileSync29, statSync as statSync20 } from "node:fs";
+import { existsSync as existsSync48, readdirSync as readdirSync10, readFileSync as readFileSync30, statSync as statSync24 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 function getSelfVersion3() {
   const req = createRequire7(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -50335,7 +50993,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path) {
   try {
-    return existsSync46(path) ? statSync20(path).size : 0;
+    return existsSync48(path) ? statSync24(path).size : 0;
   } catch {
     return 0;
   }
@@ -50347,11 +51005,11 @@ function sanitizeValue2(value) {
   return sanitizeConfigValue(value);
 }
 function readJsonc(path) {
-  if (!existsSync46(path))
+  if (!existsSync48(path))
     return { value: {} };
   try {
     return {
-      value: import_comment_json12.parse(readFileSync29(path, "utf-8"))
+      value: import_comment_json12.parse(readFileSync30(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -50367,7 +51025,7 @@ function readConfigDiagnostic(path) {
   const parsed = readJsonc(path);
   return {
     path,
-    exists: existsSync46(path),
+    exists: existsSync48(path),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -50385,7 +51043,7 @@ function reverseSlugToDirectory(slug) {
 }
 function collectPiRecentSessions() {
   const sessionsRoot = getPiSessionsRoot();
-  if (!existsSync46(sessionsRoot))
+  if (!existsSync48(sessionsRoot))
     return [];
   try {
     const slugs = readdirSync10(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -50394,7 +51052,7 @@ function collectPiRecentSessions() {
       const directory = reverseSlugToDirectory(slug);
       if (!directory)
         continue;
-      const slugDir = join39(sessionsRoot, slug);
+      const slugDir = join40(sessionsRoot, slug);
       let files;
       try {
         files = readdirSync10(slugDir).filter((name) => name.endsWith(".jsonl"));
@@ -50403,7 +51061,7 @@ function collectPiRecentSessions() {
       }
       for (const file of files) {
         try {
-          const mtime = statSync20(join39(slugDir, file)).mtimeMs;
+          const mtime = statSync24(join40(slugDir, file)).mtimeMs;
           const sessionId = file.replace(/\.jsonl$/, "");
           candidates.push({ sessionId, directory, mtime });
         } catch {}
@@ -50421,7 +51079,7 @@ function collectPiRecentSessions() {
 }
 function parseHistorianDumpMeta2(path) {
   try {
-    const xml = readFileSync29(path, "utf-8");
+    const xml = readFileSync30(path, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -50454,11 +51112,11 @@ function parseHistorianDumpMeta2(path) {
   }
 }
 function listDumpsInDir2(dir, limit) {
-  if (!existsSync46(dir))
+  if (!existsSync48(dir))
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync10(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync20(join39(dir, name));
+      const stat = statSync24(join40(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -50467,7 +51125,7 @@ function listDumpsInDir2(dir, limit) {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta = parseHistorianDumpMeta2(join39(dir, entry.name));
+      const meta = parseHistorianDumpMeta2(join40(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -50531,7 +51189,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const loaded = loadPiConfig({ cwd });
   const storageResolution = getMagicContextStorageResolution();
   const storageDirPath = storageResolution.path;
-  const dbPath = join39(storageDirPath, "context.db");
+  const dbPath = join40(storageDirPath, "context.db");
   const logFiles = inspectMagicContextLogs("pi");
   const primaryLog = logFiles.find((file) => file.exists) ?? logFiles[0];
   const otherPiExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
@@ -50548,7 +51206,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync46(settingsPath),
+      exists: existsSync48(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasPiMagicContextPackage(packages),
       packages: sanitizeValue2(packages)
@@ -50565,7 +51223,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync46(storageDirPath),
+      exists: existsSync48(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -50670,8 +51328,8 @@ var init_diagnostics_pi = __esm(() => {
 });
 
 // src/lib/logs-pi.ts
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname26, join as join40 } from "node:path";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname27, join as join41 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
 }
@@ -50727,13 +51385,13 @@ async function bundleIssueReport2(report, description, title, options = {}) {
   const truncated = bodyMarkdown !== rawBodyMarkdown;
   const cwd = options.cwd ?? process.cwd();
   const timestamp = formatTimestamp2(options.now ?? new Date);
-  const path = options.outputPath ?? join40(cwd, `magic-context-pi-issue-${timestamp}.md`);
-  mkdirSync8(dirname26(path), { recursive: true });
-  writeFileSync8(path, `${bodyMarkdown}
+  const path = options.outputPath ?? join41(cwd, `magic-context-pi-issue-${timestamp}.md`);
+  mkdirSync9(dirname27(path), { recursive: true });
+  writeFileSync9(path, `${bodyMarkdown}
 `);
-  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join40(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
+  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join41(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
   if (fullPath)
-    writeFileSync8(fullPath, `${rawBodyMarkdown}
+    writeFileSync9(fullPath, `${rawBodyMarkdown}
 `);
   return { path, bodyMarkdown, ...fullPath ? { fullPath } : {}, truncated };
 }
@@ -50745,10 +51403,10 @@ var init_logs_pi = __esm(() => {
 
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync9, spawnSync as spawnSync11 } from "node:child_process";
-import { existsSync as existsSync47, readdirSync as readdirSync11, readFileSync as readFileSync30, rmSync as rmSync9, statSync as statSync21 } from "node:fs";
+import { existsSync as existsSync49, readdirSync as readdirSync11, readFileSync as readFileSync31, rmSync as rmSync10, statSync as statSync25 } from "node:fs";
 import { createRequire as createRequire8 } from "node:module";
-import { homedir as homedir21 } from "node:os";
-import { isAbsolute as isAbsolute9, join as join41 } from "node:path";
+import { homedir as homedir22 } from "node:os";
+import { isAbsolute as isAbsolute9, join as join42 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS5,
@@ -50840,7 +51498,7 @@ function summarize(results) {
 function readJsonc2(path) {
   try {
     return {
-      value: import_comment_json13.parse(readFileSync30(path, "utf-8"))
+      value: import_comment_json13.parse(readFileSync31(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -50890,15 +51548,15 @@ function piPluginDirCandidates(packages, cwd) {
     if (resolved)
       dirs.push(resolved);
   }
-  dirs.push(join41(agentDir, "npm", "node_modules", PACKAGE_NAME2));
-  dirs.push(join41(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
-  return dirs.filter((dir) => existsSync47(join41(dir, "package.json")));
+  dirs.push(join42(agentDir, "npm", "node_modules", PACKAGE_NAME2));
+  dirs.push(join42(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
+  return dirs.filter((dir) => existsSync49(join42(dir, "package.json")));
 }
 function projectConfigPath(cwd) {
   return resolveCortexKitProjectConfigPath(cwd);
 }
 function readConfigForEmbedding(path, isProjectConfig) {
-  if (!existsSync47(path))
+  if (!existsSync49(path))
     return null;
   try {
     const raw = loadRawConfigFile({
@@ -50984,35 +51642,35 @@ function pinnedVersionFromPackageSpecifier(specifier) {
 }
 function cacheRoots(cwd) {
   const home = process.env.HOME?.trim();
-  const cacheHome = process.env.XDG_CACHE_HOME || join41(home || homedir21(), ".cache");
+  const cacheHome = process.env.XDG_CACHE_HOME || join42(home || homedir22(), ".cache");
   const piCacheRoot = getPiCacheRoot();
   return [
-    join41(piCacheRoot, "extensions"),
-    join41(piCacheRoot, "packages"),
-    join41(cacheHome, "pi", "extensions"),
-    join41(cacheHome, "pi", "packages"),
-    join41(getPiAgentConfigDir(), "cache", "extensions"),
-    join41(getPiAgentConfigDir(), "npm", "node_modules", PACKAGE_NAME2),
-    join41(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2)
+    join42(piCacheRoot, "extensions"),
+    join42(piCacheRoot, "packages"),
+    join42(cacheHome, "pi", "extensions"),
+    join42(cacheHome, "pi", "packages"),
+    join42(getPiAgentConfigDir(), "cache", "extensions"),
+    join42(getPiAgentConfigDir(), "npm", "node_modules", PACKAGE_NAME2),
+    join42(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2)
   ];
 }
 function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
   const found = new Map;
   const visit = (path, depth) => {
-    if (depth < 0 || !existsSync47(path))
+    if (depth < 0 || !existsSync49(path))
       return;
     let stat;
     try {
-      stat = statSync21(path);
+      stat = statSync25(path);
     } catch {
       return;
     }
     if (!stat.isDirectory())
       return;
-    const packageJson = join41(path, "package.json");
-    if (existsSync47(packageJson)) {
+    const packageJson = join42(path, "package.json");
+    if (existsSync49(packageJson)) {
       try {
-        const pkg = JSON.parse(readFileSync30(packageJson, "utf-8"));
+        const pkg = JSON.parse(readFileSync31(packageJson, "utf-8"));
         const name = typeof pkg.name === "string" ? pkg.name : "";
         const version = typeof pkg.version === "string" ? pkg.version : undefined;
         if (name === PACKAGE_NAME2) {
@@ -51032,7 +51690,7 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
       return;
     }
     for (const entry of entries)
-      visit(join41(path, entry), depth - 1);
+      visit(join42(path, entry), depth - 1);
   };
   for (const root of cacheRoots(cwd))
     visit(root, 5);
@@ -51093,7 +51751,7 @@ async function runHealthChecks2(options) {
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
   let piPluginInstalled = false;
-  if (!existsSync47(settingsPath)) {
+  if (!existsSync49(settingsPath)) {
     if (pi) {
       add2(results, "info", `${piVersion ? `Pi ${piVersion}` : "Pi"} found; Magic Context is not installed there (run setup to add it)`);
     }
@@ -51135,7 +51793,7 @@ async function runHealthChecks2(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync47(path)) {
+    if (!existsSync49(path)) {
       if (required) {
         add2(results, "warn", `No ${label} magic-context.jsonc found at ${path}`);
         if (userConfigMigrationRefused) {
@@ -51181,9 +51839,9 @@ async function runHealthChecks2(options) {
     checkPiModelChains(results, pi, loadedConfig.config, options.deps);
   const storage = getMagicContextStorageResolution();
   const storageDir = storage.path;
-  const dbPath = join41(storageDir, "context.db");
+  const dbPath = join42(storageDir, "context.db");
   add2(results, "info", `Shared storage: ${storageDir} (source: ${storage.source})`);
-  const existedBeforeOpen = existsSync47(dbPath);
+  const existedBeforeOpen = existsSync49(dbPath);
   if (existedBeforeOpen)
     add2(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -51412,7 +52070,7 @@ function writeDefaultMagicContextConfig(path) {
 function repair2(plan, prompts) {
   let fixed = 0;
   for (const path of plan.reasoningAgeConfigPaths) {
-    const content = readFileSync30(path, "utf8");
+    const content = readFileSync31(path, "utf8");
     const parsed = readJsonc2(path);
     if (parsed.error)
       continue;
@@ -51438,7 +52096,7 @@ function repair2(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync47(configPath)) {
+    if (!existsSync49(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -51450,7 +52108,7 @@ function repair2(plan, prompts) {
   }
   for (const path of plan.clearCachePaths) {
     try {
-      rmSync9(path, { recursive: true, force: true });
+      rmSync10(path, { recursive: true, force: true });
       prompts.log.success(`Cleared stale Pi extension cache: ${path}`);
       fixed += 1;
     } catch (error) {
@@ -51492,7 +52150,7 @@ async function runIssueFlow3(options) {
   if (options.reportPath) {
     try {
       const report = await options.deps.collectDiagnostics(options.cwd);
-      const outputPath = isAbsolute9(options.reportPath) ? options.reportPath : join41(options.cwd, options.reportPath);
+      const outputPath = isAbsolute9(options.reportPath) ? options.reportPath : join42(options.cwd, options.reportPath);
       const bundled = await bundleIssueReport2(report, "Generated non-interactively by `doctor --issue --report`.", "Magic Context diagnostic report", { cwd: options.cwd, now: options.deps.now(), outputPath });
       options.prompts.log.info(`Report written to ${bundled.path}`);
       return 0;
@@ -51576,7 +52234,7 @@ async function runDoctor3(options = {}) {
   const v22Result = await runV22BackfillCommands({
     name: "Pi",
     openDatabase: (readonly = true) => {
-      const dbPath = join41(getMagicContextStorageDir(), "context.db");
+      const dbPath = join42(getMagicContextStorageDir(), "context.db");
       v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
       return v22Db;
     },
@@ -51694,8 +52352,8 @@ var init_doctor_pi = __esm(async () => {
 });
 
 // src/commands/doctor.ts
-import { existsSync as existsSync48, rmSync as rmSync10 } from "node:fs";
-import { join as join42 } from "node:path";
+import { existsSync as existsSync50, rmSync as rmSync11 } from "node:fs";
+import { join as join43 } from "node:path";
 async function runDoctor4(options) {
   if (options.clear)
     return runClear();
@@ -51713,7 +52371,7 @@ async function runDoctor4(options) {
     const result = await runV22BackfillCommands({
       name: "Magic Context",
       openDatabase: (readonly = true) => {
-        const dbPath = join42(getMagicContextStorageDir(), "context.db");
+        const dbPath = join43(getMagicContextStorageDir(), "context.db");
         v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
         return v22Db;
       },
@@ -51733,7 +52391,7 @@ async function runDoctor4(options) {
     log3.warn(`Identity split check unavailable: ${error instanceof Error ? error.message : String(error)}`);
   }
   await init_migrate();
-  const sweepDbPath = join42(getMagicContextStorageDir(), "context.db");
+  const sweepDbPath = join43(getMagicContextStorageDir(), "context.db");
   let sweepDb = null;
   try {
     sweepDb = openExistingContextDatabaseForMutation(sweepDbPath);
@@ -51819,7 +52477,7 @@ async function runClear() {
     return 0;
   }
   const picks = await selectMany("Select caches to clear:", items.map((item, idx) => ({
-    label: `${item.adapter.displayName}${item.label ? ` (${item.label})` : ""}: ${formatSize(item.sizeBytes)} — ${item.path}`,
+    label: `${item.adapter.displayName}${item.label ? ` (${item.label})` : ""}: ${formatSize2(item.sizeBytes)} — ${item.path}`,
     value: String(idx)
   })));
   if (picks.length === 0) {
@@ -51850,8 +52508,8 @@ async function runClear() {
           failed += 1;
           continue;
         }
-      } else if (existsSync48(item.path)) {
-        rmSync10(item.path, { recursive: true, force: true });
+      } else if (existsSync50(item.path)) {
+        rmSync11(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);
     } catch (err) {
@@ -51863,7 +52521,7 @@ async function runClear() {
   outro2(failed === 0 ? "Done." : `Done with ${failed} failure(s).`);
   return failed === 0 ? 0 : 1;
 }
-function formatSize(bytes) {
+function formatSize2(bytes) {
   if (bytes < 1024)
     return `${bytes} B`;
   if (bytes < 1048576)
@@ -51912,13 +52570,16 @@ var HARNESS_LINES = [
 ];
 var SETUP_HELP = [
   "",
-  "  Usage: magic-context setup [--harness opencode|pi|omp] [--dry-run]",
+  "  Usage: magic-context setup [--harness opencode|pi|omp] [--dry-run] [--dashboard|--no-dashboard]",
   "",
   "  Interactive setup wizard: registers the Magic Context plugin with the",
-  "  selected harness and writes its Magic Context config.",
+  "  selected harness and writes its Magic Context config. Afterwards it offers",
+  "  to install the Magic Context Dashboard desktop app (interactive runs only).",
   "",
   "  Options:",
   "    --dry-run             Preview the wizard without writing any files",
+  "    --dashboard           Install or update the dashboard without asking",
+  "    --no-dashboard        Skip the dashboard offer",
   ...HARNESS_LINES,
   ""
 ].join(`
@@ -51971,7 +52632,7 @@ var SINGLE_STORE_HELP = [
 `);
 var MERGE_IDENTITY_HELP = [
   "",
-  "  Usage: magic-context doctor merge-identities [--from <identity> --to <identity>] [--apply] [--force] [--db <path>]",
+  "  Usage: magic-context doctor merge-identities [--from <identity> --to <identity>] [--apply] [--force] [--verbose] [--db <path>] [--backup-root <dir>]",
   "",
   "  Merge every project-scoped row from one project identity into another.",
   "",
@@ -51981,8 +52642,10 @@ var MERGE_IDENTITY_HELP = [
   "    (no flags)          List splits; --from/--to previews without writing",
   "    --apply             Confirm the reviewed preview; hosts must be closed",
   "    --force             Permit a target not resolving on this machine",
+  "    --verbose           List every missing source-only folder and orphaned sidecar",
   "    --db <path>         Use this context.db instead of the shared one",
   "    --host-db <path>    Read session directories from this host database",
+  "    --backup-root <dir> Store the backup under this directory",
   "    Legacy alias: doctor merge-identity; --dry-run previews, --yes applies",
   ""
 ].join(`