@cortexkit/magic-context 0.16.2 → 0.17.0

package/dist/index.js

@@ -11053,7 +11053,7 @@ function printNextSteps(adapter) {
   if (adapter.kind === "opencode") {
     note([
       "Restart OpenCode (or reload your session) so the plugin loads.",
-      "Verify with: bunx --bun @cortexkit/magic-context@latest doctor"
+      "Verify with: npx @cortexkit/magic-context@latest doctor"
     ].join(`
 `), "Next steps");
     return;
@@ -11061,7 +11061,7 @@ function printNextSteps(adapter) {
   if (adapter.kind === "pi") {
     note([
       "Restart your Pi session so the extension registers.",
-      "Verify with: bunx --bun @cortexkit/magic-context@latest doctor --harness pi"
+      "Verify with: npx @cortexkit/magic-context@latest doctor --harness pi"
     ].join(`
 `), "Next steps");
   }
@@ -11096,14 +11096,384 @@ function getOpenCodeCacheDir() {
 }
 var init_data_path = () => {};
 
+// ../../node_modules/.bun/nanotar@0.3.0/node_modules/nanotar/dist/index.mjs
+function parseTar(data, opts) {
+  const buffer = data.buffer || data;
+  const files = [];
+  let offset = 0;
+  let nextExtendedHeader;
+  let globalExtendedHeader;
+  while (offset < buffer.byteLength - 512) {
+    let name = _readString(buffer, offset, 100);
+    if (name.length === 0) {
+      break;
+    }
+    if (nextExtendedHeader) {
+      const longName = nextExtendedHeader.path || nextExtendedHeader.linkpath;
+      if (longName) {
+        name = longName;
+      }
+    }
+    const mode = _readString(buffer, offset + 100, 8).trim();
+    const uid = Number.parseInt(_readString(buffer, offset + 108, 8));
+    const gid = Number.parseInt(_readString(buffer, offset + 116, 8));
+    const size = _readNumber(buffer, offset + 124, 12);
+    const seek = 512 + 512 * Math.trunc(size / 512) + (size % 512 ? 512 : 0);
+    const mtime = _readNumber(buffer, offset + 136, 12);
+    const _type = _readString(buffer, offset + 156, 1) || "0";
+    const type = tarItemTypeMap[_type] || _type;
+    switch (type) {
+      case "extendedHeader":
+      case "globalExtendedHeader": {
+        const headers = _parseExtendedHeaders(new Uint8Array(buffer, offset + 512, size));
+        if (type === "extendedHeader") {
+          nextExtendedHeader = headers;
+        } else {
+          nextExtendedHeader = undefined;
+          globalExtendedHeader = {
+            ...globalExtendedHeader,
+            ...headers
+          };
+        }
+        offset += seek;
+        continue;
+      }
+      case "gnuLongFileName":
+      case "gnuOldLongFileName":
+      case "gnuLongLinkName": {
+        nextExtendedHeader = { path: _readString(buffer, offset + 512, size) };
+        offset += seek;
+        continue;
+      }
+    }
+    const user = _readString(buffer, offset + 265, 32);
+    const group = _readString(buffer, offset + 297, 32);
+    name = _sanitizePath(name);
+    const meta = {
+      name,
+      type,
+      size,
+      attrs: {
+        ...globalExtendedHeader,
+        ...nextExtendedHeader,
+        mode,
+        uid,
+        gid,
+        mtime,
+        user,
+        group
+      }
+    };
+    nextExtendedHeader = undefined;
+    if (opts?.filter && !opts.filter(meta)) {
+      offset += seek;
+      continue;
+    }
+    if (opts?.metaOnly) {
+      files.push(meta);
+      offset += seek;
+      continue;
+    }
+    const data2 = size === 0 ? undefined : new Uint8Array(buffer, offset + 512, size);
+    files.push({
+      ...meta,
+      data: data2,
+      get text() {
+        return new TextDecoder().decode(this.data);
+      }
+    });
+    offset += seek;
+  }
+  return files;
+}
+async function parseTarGzip(data, opts = {}) {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(new Uint8Array(data));
+      controller.close();
+    }
+  }).pipeThrough(new DecompressionStream(opts.compression ?? "gzip"));
+  const decompressedData = await new Response(stream).arrayBuffer();
+  return parseTar(decompressedData, opts);
+}
+function _sanitizePath(path2) {
+  let normalized = path2.replace(/\\/g, "/");
+  normalized = normalized.replace(/^[a-zA-Z]:\//, "");
+  normalized = normalized.replace(/^\/+/, "");
+  const hasLeadingDotSlash = normalized.startsWith("./");
+  const parts = normalized.split("/");
+  const resolved = [];
+  for (const part of parts) {
+    if (part === "..") {
+      resolved.pop();
+    } else if (part !== "." && part !== "") {
+      resolved.push(part);
+    }
+  }
+  let result = resolved.join("/");
+  if (hasLeadingDotSlash && !result.startsWith("./")) {
+    result = "./" + result;
+  }
+  if (path2.endsWith("/") && !result.endsWith("/")) {
+    result += "/";
+  }
+  return result;
+}
+function _readString(buffer, offset, size) {
+  const view = new Uint8Array(buffer, offset, size);
+  const i = view.indexOf(0);
+  const td = new TextDecoder;
+  return td.decode(i === -1 ? view : view.slice(0, i));
+}
+function _readNumber(buffer, offset, size) {
+  const view = new Uint8Array(buffer, offset, size);
+  let str = "";
+  for (let i = 0;i < size; i++) {
+    str += String.fromCodePoint(view[i]);
+  }
+  return Number.parseInt(str, 8);
+}
+function _parseExtendedHeaders(data) {
+  const dataStr = new TextDecoder().decode(data);
+  const headers = {};
+  for (const line of dataStr.split(`
+`)) {
+    const s = line.split(" ")[1]?.split("=");
+    if (s) {
+      headers[s[0]] = s[1];
+    }
+  }
+  return headers;
+}
+var tarItemTypeMap;
+var init_dist3 = __esm(() => {
+  tarItemTypeMap = {
+    "0": "file",
+    "1": "hardLink",
+    "2": "symbolicLink",
+    "3": "characterDevice",
+    "4": "blockDevice",
+    "5": "directory",
+    "6": "fifo",
+    "7": "contiguousFile",
+    g: "globalExtendedHeader",
+    x: "extendedHeader",
+    D: "gnuDirectory",
+    I: "gnuInodeMetadata",
+    K: "gnuLongLinkName",
+    L: "gnuLongFileName",
+    N: "gnuOldLongFileName",
+    M: "gnuMultiVolume",
+    S: "gnuSparseFile",
+    E: "gnuExtendedSparse",
+    A: "solarisAcl",
+    V: "solarisVolumeLabel",
+    X: "solarisOldExtendedHeader"
+  };
+});
+
+// ../plugin/src/shared/logger.ts
+import * as fs from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+function flush() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  if (buffer.length === 0)
+    return;
+  const data = buffer.join("");
+  buffer = [];
+  try {
+    fs.appendFileSync(logFile, data);
+  } catch {}
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, FLUSH_INTERVAL_MS);
+}
+function log2(message, data) {
+  if (isTestEnv)
+    return;
+  try {
+    const timestamp = new Date().toISOString();
+    const serialized = data === undefined ? "" : data instanceof Error ? ` ${data.message}${data.stack ? `
+${data.stack}` : ""}` : ` ${JSON.stringify(data)}`;
+    buffer.push(`[${timestamp}] ${message}${serialized}
+`);
+    if (buffer.length >= BUFFER_SIZE_LIMIT) {
+      flush();
+    } else {
+      scheduleFlush();
+    }
+  } catch {}
+}
+var logFile, isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
+var init_logger = __esm(() => {
+  logFile = path2.join(os2.tmpdir(), "magic-context.log");
+  buffer = [];
+  if (!isTestEnv) {
+    process.on("exit", flush);
+  }
+});
+
+// ../plugin/src/shared/native-binding.ts
+var exports_native_binding = {};
+__export(exports_native_binding, {
+  resolveBetterSqliteNativeBinding: () => resolveBetterSqliteNativeBinding
+});
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import * as path3 from "node:path";
+function logInfo(message) {
+  log2(`${PREFIX} ${message}`);
+}
+function logWarn(message) {
+  log2(`${PREFIX} WARN ${message}`);
+}
+function probeAbi(binaryPath) {
+  const expected = process.versions.modules;
+  try {
+    const sandbox = { exports: {} };
+    process.dlopen(sandbox, binaryPath);
+    return { ok: true };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const pair = message.match(/NODE_MODULE_VERSION (\d+).*NODE_MODULE_VERSION (\d+)/s);
+    if (pair?.[1] && pair[2]) {
+      return { ok: false, expected: pair[2], actual: pair[1] };
+    }
+    const single = message.match(/NODE_MODULE_VERSION[ =:]+(\d+)/);
+    if (single?.[1]) {
+      return { ok: false, expected, actual: single[1] };
+    }
+    logWarn(`could not parse ABI from dlopen error: ${message}`);
+    return { ok: false, expected, actual: null };
+  }
+}
+function resolveBetterSqlite3OnDisk(requireFn) {
+  try {
+    const pkgJsonPath = requireFn.resolve("better-sqlite3/package.json");
+    const pkgDir = path3.dirname(pkgJsonPath);
+    const pkgJson = requireFn(pkgJsonPath);
+    const binaryPath = path3.join(pkgDir, "build", "Release", "better_sqlite3.node");
+    return { binaryPath, pkgVersion: pkgJson.version };
+  } catch (err) {
+    logWarn(`could not resolve better-sqlite3 in node_modules: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function getCachedBinaryPath(pkgVersion, abi) {
+  return path3.join(getCacheDir(), "cortexkit", "native-bindings", "better-sqlite3", `v${pkgVersion}`, `electron-v${abi}-${process.platform}-${process.arch}`, "better_sqlite3.node");
+}
+async function downloadElectronPrebuild(pkgVersion, abi) {
+  const filename = `better-sqlite3-v${pkgVersion}-electron-v${abi}-${process.platform}-${process.arch}.tar.gz`;
+  const url = `https://github.com/WiseLibs/better-sqlite3/releases/download/v${pkgVersion}/${filename}`;
+  logInfo(`downloading ${url}`);
+  const response = await fetch(url, {
+    redirect: "follow",
+    headers: { "User-Agent": "magic-context-plugin/native-binding" }
+  });
+  if (!response.ok) {
+    throw new Error(`failed to download Electron prebuild (HTTP ${response.status} ${response.statusText}) from ${url}`);
+  }
+  const tarballBytes = new Uint8Array(await response.arrayBuffer());
+  logInfo(`downloaded ${(tarballBytes.length / 1024).toFixed(1)} KB; extracting`);
+  const files = await parseTarGzip(tarballBytes);
+  const nodeFile = files.find((f) => f.name.endsWith("better_sqlite3.node"));
+  if (!nodeFile?.data) {
+    const names = files.map((f) => f.name).join(", ");
+    throw new Error(`Electron prebuild tarball did not contain better_sqlite3.node; got: [${names}]`);
+  }
+  return nodeFile.data instanceof Uint8Array ? nodeFile.data : new Uint8Array(nodeFile.data);
+}
+async function resolveBetterSqliteNativeBinding() {
+  if (!process.versions.electron) {
+    return null;
+  }
+  if (inFlight) {
+    return inFlight;
+  }
+  const promise = (async () => {
+    const expected = process.versions.modules;
+    logInfo(`Electron detected (v${process.versions.electron}, NODE_MODULE_VERSION ${expected}); verifying better-sqlite3 binding`);
+    const requireFn = createRequire2(import.meta.url);
+    const resolved = resolveBetterSqlite3OnDisk(requireFn);
+    if (!resolved) {
+      return null;
+    }
+    const { binaryPath: diskPath, pkgVersion } = resolved;
+    if (existsSync9(diskPath)) {
+      const diskProbe = probeAbi(diskPath);
+      if (diskProbe.ok) {
+        logInfo(`on-disk binary already matches Electron ABI v${expected}; using default bindings() lookup`);
+        return null;
+      }
+      logInfo(`on-disk binary ABI ${diskProbe.actual ?? "unknown"} != required ${expected}; will use Electron prebuild`);
+    } else {
+      logWarn(`expected better-sqlite3 binary not found at ${diskPath}; will fetch Electron prebuild anyway`);
+    }
+    const cachedPath = getCachedBinaryPath(pkgVersion, expected);
+    if (existsSync9(cachedPath)) {
+      const cachedProbe = probeAbi(cachedPath);
+      if (cachedProbe.ok) {
+        logInfo(`using cached Electron prebuild at ${cachedPath}`);
+        return cachedPath;
+      }
+      logWarn(`cached binary at ${cachedPath} has wrong ABI (${cachedProbe.actual ?? "unknown"} != ${expected}); refetching`);
+    }
+    mkdirSync4(path3.dirname(cachedPath), { recursive: true });
+    const nodeFileBytes = await downloadElectronPrebuild(pkgVersion, expected);
+    writeFileSync6(cachedPath, nodeFileBytes);
+    logInfo(`cached Electron prebuild at ${cachedPath} (${(nodeFileBytes.length / 1024).toFixed(1)} KB)`);
+    const finalProbe = probeAbi(cachedPath);
+    if (!finalProbe.ok) {
+      throw new Error(`downloaded Electron prebuild has wrong ABI (${finalProbe.actual ?? "unknown"} != ${expected}); refusing to use`);
+    }
+    return cachedPath;
+  })();
+  inFlight = promise;
+  try {
+    return await promise;
+  } finally {
+    if (inFlight === promise) {
+      inFlight = null;
+    }
+  }
+}
+var PREFIX = "[native-binding]", inFlight = null;
+var init_native_binding = __esm(() => {
+  init_dist3();
+  init_data_path();
+  init_logger();
+});
+
 // ../plugin/src/shared/sqlite.ts
-var isBun, bunSpec, betterSpec, sqliteModule, DatabaseImpl, Database;
+var isBun, bunSpec, betterSpec, electronNativeBinding, sqliteModule, RawDatabaseImpl, DatabaseImpl, Database;
 var init_sqlite = __esm(async () => {
   isBun = typeof process !== "undefined" && typeof process.versions?.bun === "string";
   bunSpec = "bun:" + "sqlite";
   betterSpec = "better-" + "sqlite3";
+  electronNativeBinding = isBun ? null : await (async () => {
+    const mod = await Promise.resolve().then(() => (init_native_binding(), exports_native_binding));
+    return mod.resolveBetterSqliteNativeBinding();
+  })();
   sqliteModule = isBun ? await import(bunSpec) : await import(betterSpec);
-  DatabaseImpl = isBun ? sqliteModule.Database : sqliteModule.default;
+  RawDatabaseImpl = isBun ? sqliteModule.Database : sqliteModule.default;
+  DatabaseImpl = electronNativeBinding == null ? RawDatabaseImpl : class DatabaseWithElectronBinding extends RawDatabaseImpl {
+    constructor(filename, options) {
+      const fallback = electronNativeBinding;
+      super(filename, {
+        ...options,
+        nativeBinding: options?.nativeBinding ?? fallback
+      });
+    }
+  };
   Database = DatabaseImpl;
 });
 
@@ -11119,20 +11489,20 @@ __export(exports_migrate, {
   formatPiFilenameTimestamp: () => formatPiFilenameTimestamp
 });
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join9 } from "node:path";
 function defaultOpenCodeDbPath() {
-  return join7(homedir5(), ".local", "share", "opencode", "opencode.db");
+  return join9(homedir5(), ".local", "share", "opencode", "opencode.db");
 }
 function defaultCortexkitDbPath() {
-  return join7(getMagicContextStorageDir(), "context.db");
+  return join9(getMagicContextStorageDir(), "context.db");
 }
 function defaultPiSessionsRoot() {
-  return join7(homedir5(), ".pi", "agent", "sessions");
+  return join9(homedir5(), ".pi", "agent", "sessions");
 }
 function defaultFs() {
-  return { existsSync: existsSync9, mkdirSync: mkdirSync4, writeFileSync: writeFileSync6 };
+  return { existsSync: existsSync10, mkdirSync: mkdirSync5, writeFileSync: writeFileSync7 };
 }
 function stmt(db, sql) {
   return db.prepare(sql);
@@ -11529,7 +11899,7 @@ function ensureValidOptions(opts) {
   }
 }
 function migrateOpenCodeSessionToPi(opts) {
-  const fs = opts.fs ?? defaultFs();
+  const fs2 = opts.fs ?? defaultFs();
   const now = opts.now ?? new Date;
   const opencodeDbPath = opts.opencodeDbPath ?? defaultOpenCodeDbPath();
   const piSessionsRoot = opts.piSessionsRoot ?? defaultPiSessionsRoot();
@@ -11555,7 +11925,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 = join7(piSessionsRoot, projectPathToPiDirSlug(cwd));
+    const outputDir = join9(piSessionsRoot, projectPathToPiDirSlug(cwd));
     const buildResult = buildPiEntries({
       session,
       messages,
@@ -11581,14 +11951,14 @@ function migrateOpenCodeSessionToPi(opts) {
       });
     }
     const compactionMarker = insertCompactionMarker(buildResult.entries, copyResult.lastCompartmentEndPiEntryId);
-    const outputPath = join7(outputDir, `${formatPiFilenameTimestamp(now)}_${buildResult.piSessionId}.jsonl`);
+    const outputPath = join9(outputDir, `${formatPiFilenameTimestamp(now)}_${buildResult.piSessionId}.jsonl`);
     const jsonl = `${buildResult.entries.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `;
     if (!opts.dryRun) {
-      if (!fs.existsSync(outputDir))
-        fs.mkdirSync(outputDir, { recursive: true });
-      fs.writeFileSync(outputPath, jsonl);
+      if (!fs2.existsSync(outputDir))
+        fs2.mkdirSync(outputDir, { recursive: true });
+      fs2.writeFileSync(outputPath, jsonl);
     }
     return {
       outputPath,
@@ -11651,7 +12021,7 @@ function printMigrateHelp() {
     --from opencode --to pi
 
   Usage:
-    bunx --bun @cortexkit/opencode-magic-context@latest doctor migrate \\
+    npx @cortexkit/opencode-magic-context@latest doctor migrate \\
       --from opencode --to pi --session ses_xxx [--max-messages N] [--dry-run]
 
   Fidelity:
@@ -11955,10 +12325,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12269,11 +12639,11 @@ function aborted(x3, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -12511,7 +12881,7 @@ function formatError(error, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error2, path2 = []) => {
+  const processError = (error2, path4 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12521,7 +12891,7 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12553,8 +12923,8 @@ function treeifyError(error, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24829,13 +25199,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path2 = ref.slice(1).split("/").filter(Boolean);
-  if (path2.length === 0) {
+  const path4 = ref.slice(1).split("/").filter(Boolean);
+  if (path4.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path2[0] === defsKey) {
-    const key = path2[1];
+  if (path4[0] === defsKey) {
+    const key = path4[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -25790,9 +26160,9 @@ var init_magic_context = __esm(() => {
 });
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync6 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname6, isAbsolute, resolve as resolve2 } from "node:path";
+import { dirname as dirname7, isAbsolute, resolve as resolve2 } from "node:path";
 function substituteConfigVariables(input) {
   const warnings = [];
   let text2 = input.text;
@@ -25809,7 +26179,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text: text2, warnings };
   }
-  const configDir = input.configPath ? dirname6(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname7(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -25831,7 +26201,7 @@ function substituteConfigVariables(input) {
     } else if (!isAbsolute(filePath)) {
       filePath = resolve2(configDir, filePath);
     }
-    if (!existsSync10(filePath)) {
+    if (!existsSync11(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
@@ -25855,19 +26225,19 @@ var init_variable = __esm(() => {
 });
 
 // ../plugin/src/config/index.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 function getUserConfigBasePath() {
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir7(), ".config");
-  return join8(configRoot, "opencode", CONFIG_FILE_BASENAME);
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join10(homedir7(), ".config");
+  return join10(configRoot, "opencode", CONFIG_FILE_BASENAME);
 }
 function getProjectConfigBasePath(directory) {
-  return join8(directory, ".opencode", CONFIG_FILE_BASENAME);
+  return join10(directory, ".opencode", CONFIG_FILE_BASENAME);
 }
 function loadConfigFile(configPath) {
   try {
-    if (!existsSync11(configPath)) {
+    if (!existsSync12(configPath)) {
       return null;
     }
     const rawText = readFileSync7(configPath, "utf-8");
@@ -26044,7 +26414,7 @@ function parsePluginConfig(rawConfig) {
 }
 function loadPluginConfig(directory) {
   const userDetected = detectConfigFile(getUserConfigBasePath());
-  const rootDetected = detectConfigFile(join8(directory, CONFIG_FILE_BASENAME));
+  const rootDetected = detectConfigFile(join10(directory, CONFIG_FILE_BASENAME));
   const dotOpenCodeDetected = detectConfigFile(getProjectConfigBasePath(directory));
   const projectDetected = rootDetected.format !== "none" ? rootDetected : dotOpenCodeDetected;
   const userLoaded = userDetected.format === "none" ? null : loadConfigFile(userDetected.path);
@@ -26187,59 +26557,9 @@ function truncate(text2) {
 }
 var DEFAULT_TIMEOUT_MS = 1e4, MAX_PREVIEW_CHARS = 240;
 
-// ../plugin/src/shared/logger.ts
-import * as fs from "node:fs";
-import * as os2 from "node:os";
-import * as path2 from "node:path";
-function flush() {
-  if (flushTimer) {
-    clearTimeout(flushTimer);
-    flushTimer = null;
-  }
-  if (buffer.length === 0)
-    return;
-  const data = buffer.join("");
-  buffer = [];
-  try {
-    fs.appendFileSync(logFile, data);
-  } catch {}
-}
-function scheduleFlush() {
-  if (flushTimer)
-    return;
-  flushTimer = setTimeout(() => {
-    flushTimer = null;
-    flush();
-  }, FLUSH_INTERVAL_MS);
-}
-function log2(message, data) {
-  if (isTestEnv)
-    return;
-  try {
-    const timestamp = new Date().toISOString();
-    const serialized = data === undefined ? "" : data instanceof Error ? ` ${data.message}${data.stack ? `
-${data.stack}` : ""}` : ` ${JSON.stringify(data)}`;
-    buffer.push(`[${timestamp}] ${message}${serialized}
-`);
-    if (buffer.length >= BUFFER_SIZE_LIMIT) {
-      flush();
-    } else {
-      scheduleFlush();
-    }
-  } catch {}
-}
-var logFile, isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50;
-var init_logger = __esm(() => {
-  logFile = path2.join(os2.tmpdir(), "magic-context.log");
-  buffer = [];
-  if (!isTestEnv) {
-    process.on("exit", flush);
-  }
-});
-
 // ../plugin/src/shared/tui-config.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname7, join as join10 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join11 } from "node:path";
 function isMagicContextEntry(entry) {
   if (!entry)
     return false;
@@ -26253,11 +26573,11 @@ function isMagicContextEntry(entry) {
 }
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join10(configDir, "tui.jsonc");
-  const jsonPath = join10(configDir, "tui.json");
-  if (existsSync12(jsoncPath))
+  const jsoncPath = join11(configDir, "tui.jsonc");
+  const jsonPath = join11(configDir, "tui.json");
+  if (existsSync13(jsoncPath))
     return jsoncPath;
-  if (existsSync12(jsonPath))
+  if (existsSync13(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -26265,7 +26585,7 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync12(configPath)) {
+    if (existsSync13(configPath)) {
       const raw = readFileSync8(configPath, "utf-8");
       config2 = import_comment_json5.parse(raw) ?? {};
     }
@@ -26285,8 +26605,8 @@ function ensureTuiPluginEntry() {
       plugins.push(PLUGIN_ENTRY3);
     }
     config2.plugin = plugins;
-    mkdirSync5(dirname7(configPath), { recursive: true });
-    writeFileSync7(configPath, `${import_comment_json5.stringify(config2, null, 2)}
+    mkdirSync6(dirname8(configPath), { recursive: true });
+    writeFileSync8(configPath, `${import_comment_json5.stringify(config2, null, 2)}
 `);
     log2(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -26354,12 +26674,12 @@ var init_compartment_parser = __esm(() => {
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync13, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync2 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
+import { existsSync as existsSync14, readdirSync as readdirSync2, readFileSync as readFileSync9, statSync as statSync2 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir8, tmpdir as tmpdir3, userInfo } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function getSelfVersion() {
-  const require2 = createRequire2(import.meta.url);
+  const require2 = createRequire3(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
     try {
       const pkg = require2(relPath);
@@ -26371,26 +26691,26 @@ function getSelfVersion() {
   return "unknown";
 }
 function getPluginCacheInfo() {
-  const path3 = join11(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY_WITH_VERSION);
+  const path4 = join12(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY_WITH_VERSION);
   let cached2;
   try {
-    const installedPkgPath = join11(path3, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
-    if (existsSync13(installedPkgPath)) {
+    const installedPkgPath = join12(path4, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
+    if (existsSync14(installedPkgPath)) {
       const pkg = JSON.parse(readFileSync9(installedPkgPath, "utf-8"));
       cached2 = typeof pkg.version === "string" ? pkg.version : undefined;
     }
   } catch {
     cached2 = undefined;
   }
-  return { path: path3, cached: cached2, latest: getSelfVersion() };
+  return { path: path4, cached: cached2, latest: getSelfVersion() };
 }
 function getStorageDir() {
-  const dataHome = process.env.XDG_DATA_HOME || join11(homedir8(), ".local", "share");
-  return join11(dataHome, "cortexkit", "magic-context");
+  const dataHome = process.env.XDG_DATA_HOME || join12(homedir8(), ".local", "share");
+  return join12(dataHome, "cortexkit", "magic-context");
 }
-function fileSize(path3) {
+function fileSize(path4) {
   try {
-    return existsSync13(path3) ? statSync2(path3).size : 0;
+    return existsSync14(path4) ? statSync2(path4).size : 0;
   } catch {
     return 0;
   }
@@ -26423,11 +26743,11 @@ function sanitizeValue(value) {
   }
   return value;
 }
-function readConfig2(path3) {
-  if (!existsSync13(path3))
+function readConfig2(path4) {
+  if (!existsSync14(path4))
     return { value: null };
   try {
-    const raw = readFileSync9(path3, "utf-8");
+    const raw = readFileSync9(path4, "utf-8");
     const value = import_comment_json6.parse(raw);
     return { value };
   } catch (error48) {
@@ -26448,9 +26768,9 @@ function configHasPluginEntry(config2) {
     return false;
   });
 }
-function parseHistorianDumpMeta(path3) {
+function parseHistorianDumpMeta(path4) {
   try {
-    const xml = readFileSync9(path3, "utf-8");
+    const xml = readFileSync9(path4, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -26483,13 +26803,13 @@ function parseHistorianDumpMeta(path3) {
   }
 }
 function collectHistorianDumps() {
-  const dir = join11(tmpdir3(), "magic-context-historian");
-  if (!existsSync13(dir)) {
+  const dir = join12(tmpdir3(), "magic-context-historian");
+  if (!existsSync14(dir)) {
     return { dir, count: 0, recent: [] };
   }
   try {
     const entries = readdirSync2(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync2(join11(dir, name));
+      const stat = statSync2(join12(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -26498,7 +26818,7 @@ function collectHistorianDumps() {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, 5).map((entry) => {
-      const meta3 = parseHistorianDumpMeta(join11(dir, entry.name));
+      const meta3 = parseHistorianDumpMeta(join12(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -26517,8 +26837,8 @@ function collectHistorianDumps() {
   }
 }
 async function collectHistorianFailures(storageDirPath) {
-  const contextDbPath = join11(storageDirPath, "context.db");
-  if (!existsSync13(contextDbPath))
+  const contextDbPath = join12(storageDirPath, "context.db");
+  if (!existsSync14(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -26557,9 +26877,9 @@ async function collectDiagnostics() {
   const tuiConfig = readConfig2(configPaths.tuiConfig);
   const magicContextConfig = readConfig2(configPaths.magicContextConfig);
   const storageDirPath = getStorageDir();
-  const contextDbPath = join11(storageDirPath, "context.db");
-  const logPath = join11(tmpdir3(), "magic-context.log");
-  const logFileSize = existsSync13(logPath) ? statSync2(logPath).size : 0;
+  const contextDbPath = join12(storageDirPath, "context.db");
+  const logPath = join12(tmpdir3(), "magic-context.log");
+  const logFileSize = existsSync14(logPath) ? statSync2(logPath).size : 0;
   const conflictResult = detectConflicts(process.cwd());
   return {
     timestamp: new Date().toISOString(),
@@ -26573,14 +26893,14 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync13(configPaths.magicContextConfig),
+      exists: existsSync14(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
     pluginCache: getPluginCacheInfo(),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync13(storageDirPath),
+      exists: existsSync14(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     conflicts: {
@@ -26589,7 +26909,7 @@ async function collectDiagnostics() {
     },
     logFile: {
       path: logPath,
-      exists: existsSync13(logPath),
+      exists: existsSync14(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     },
     historianDumps: collectHistorianDumps(),
@@ -26690,9 +27010,9 @@ var init_diagnostics_opencode = __esm(() => {
 });
 
 // src/lib/logs-opencode.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir9, userInfo as userInfo2 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function escapeRegex3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -26783,10 +27103,10 @@ async function bundleIssueReport(report, description, _title) {
     "```"
   ].join(`
 `);
-  const path3 = join12(process.cwd(), `magic-context-issue-${formatTimestamp(new Date)}.md`);
-  writeFileSync8(path3, `${bodyMarkdown}
+  const path4 = join13(process.cwd(), `magic-context-issue-${formatTimestamp(new Date)}.md`);
+  writeFileSync9(path4, `${bodyMarkdown}
 `);
-  return { path: path3, bodyMarkdown };
+  return { path: path4, bodyMarkdown };
 }
 var SECRET_PATTERNS, HISTORIAN_LOG_PATTERNS;
 var init_logs_opencode = __esm(() => {
@@ -26871,10 +27191,10 @@ var init_logs_opencode = __esm(() => {
 
 // src/commands/doctor-opencode.ts
 import { execSync as execSync3, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync14, readdirSync as readdirSync3, readFileSync as readFileSync11, rmSync, statSync as statSync3, writeFileSync as writeFileSync9 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
+import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync11, rmSync, statSync as statSync3, writeFileSync as writeFileSync10 } from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
 import { homedir as homedir10, tmpdir as tmpdir4 } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function fetchNpmLatest(pkg, timeoutMs = 5000) {
   try {
     const controller = new AbortController;
@@ -26896,7 +27216,7 @@ async function fetchNpmLatest(pkg, timeoutMs = 5000) {
   }
 }
 function getSelfVersion2() {
-  const req = createRequire3(import.meta.url);
+  const req = createRequire4(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
     try {
       const pkg = req(relPath);
@@ -26924,21 +27244,21 @@ function compareVersions(a, b) {
 }
 async function clearPluginCache(force = false) {
   const cacheDir = getOpenCodeCacheDir();
-  const pluginCacheDir = join13(cacheDir, "packages", PLUGIN_ENTRY_WITH_VERSION2);
-  if (!existsSync14(pluginCacheDir)) {
+  const pluginCacheDir = join14(cacheDir, "packages", PLUGIN_ENTRY_WITH_VERSION2);
+  if (!existsSync15(pluginCacheDir)) {
     return { action: "not_found", path: pluginCacheDir };
   }
   let cachedVersion;
   try {
-    const installedPkgPath = join13(pluginCacheDir, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
-    if (existsSync14(installedPkgPath)) {
+    const installedPkgPath = join14(pluginCacheDir, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
+    if (existsSync15(installedPkgPath)) {
       const pkg = JSON.parse(readFileSync11(installedPkgPath, "utf-8"));
       if (typeof pkg?.version === "string") {
         cachedVersion = pkg.version;
       }
     }
   } catch {}
-  const require2 = createRequire3(import.meta.url);
+  const require2 = createRequire4(import.meta.url);
   let selfVersion;
   for (const relPath of ["../../package.json", "../package.json"]) {
     try {
@@ -27044,7 +27364,7 @@ async function runIssueFlow() {
   }
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync14(magicContextConfigPath)) {
+  if (!existsSync15(magicContextConfigPath)) {
     return { issues: 0 };
   }
   let rawText;
@@ -27197,7 +27517,7 @@ async function runDoctor(options = {}) {
   } else {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
-  if (existsSync14(paths.magicContextConfig)) {
+  if (existsSync15(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = readFileSync11(paths.magicContextConfig, "utf-8");
@@ -27225,7 +27545,7 @@ async function runDoctor(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync14(paths.magicContextConfig)) {
+  if (existsSync15(paths.magicContextConfig)) {
     try {
       const mcRaw = readFileSync11(paths.magicContextConfig, "utf-8");
       const mcConfig = import_comment_json7.parse(mcRaw);
@@ -27303,7 +27623,7 @@ async function runDoctor(options = {}) {
         fixed++;
       }
       if (mcChanged) {
-        writeFileSync9(paths.magicContextConfig, `${import_comment_json7.stringify(mcConfig, null, 2)}
+        writeFileSync10(paths.magicContextConfig, `${import_comment_json7.stringify(mcConfig, null, 2)}
 `);
       }
     } catch {
@@ -27344,7 +27664,7 @@ async function runDoctor(options = {}) {
               rawPlugins[existingIdx] = PLUGIN_ENTRY_WITH_VERSION2;
             }
             config2.plugin = rawPlugins;
-            writeFileSync9(paths.opencodeConfig, `${import_comment_json7.stringify(config2, null, 2)}
+            writeFileSync10(paths.opencodeConfig, `${import_comment_json7.stringify(config2, null, 2)}
 `);
             pass(`Upgraded plugin entry in ${configName}: ${oldEntryStr} → ${PLUGIN_ENTRY_WITH_VERSION2}`);
             fixed++;
@@ -27353,7 +27673,7 @@ async function runDoctor(options = {}) {
       } else {
         rawPlugins.push(PLUGIN_ENTRY_WITH_VERSION2);
         config2.plugin = rawPlugins;
-        writeFileSync9(paths.opencodeConfig, `${import_comment_json7.stringify(config2, null, 2)}
+        writeFileSync10(paths.opencodeConfig, `${import_comment_json7.stringify(config2, null, 2)}
 `);
         pass(`Added plugin to ${configName}`);
         fixed++;
@@ -27384,7 +27704,7 @@ async function runDoctor(options = {}) {
     pass("Added TUI sidebar plugin to tui.json");
     warn("Restart OpenCode to see the sidebar");
     fixed++;
-  } else if (existsSync14(paths.tuiConfig)) {
+  } else if (existsSync15(paths.tuiConfig)) {
     try {
       const tuiRaw = readFileSync11(paths.tuiConfig, "utf-8");
       const tuiConfig = import_comment_json7.parse(tuiRaw);
@@ -27415,7 +27735,7 @@ async function runDoctor(options = {}) {
               tuiRawPlugins[tuiIdx] = PLUGIN_ENTRY_WITH_VERSION2;
             }
             tuiConfig.plugin = tuiRawPlugins;
-            writeFileSync9(paths.tuiConfig, `${import_comment_json7.stringify(tuiConfig, null, 2)}
+            writeFileSync10(paths.tuiConfig, `${import_comment_json7.stringify(tuiConfig, null, 2)}
 `);
             pass(`Upgraded TUI plugin: ${tuiEntryStr} → ${PLUGIN_ENTRY_WITH_VERSION2}`);
             fixed++;
@@ -27432,7 +27752,7 @@ async function runDoctor(options = {}) {
   } else {
     pass("TUI sidebar plugin configured (tui.json created)");
   }
-  if (existsSync14(paths.magicContextConfig)) {
+  if (existsSync15(paths.magicContextConfig)) {
     try {
       const mcRaw = readFileSync11(paths.magicContextConfig, "utf-8");
       const mcConfig = import_comment_json7.parse(mcRaw);
@@ -27452,8 +27772,8 @@ async function runDoctor(options = {}) {
     failCount += embeddingCheck.issues;
   else
     passCount++;
-  const dbPath = join13(getMagicContextStorageDir(), "context.db");
-  if (!existsSync14(dbPath)) {
+  const dbPath = join14(getMagicContextStorageDir(), "context.db");
+  if (!existsSync15(dbPath)) {
     log.info(`Shared context DB not yet created at ${dbPath} (will be created on first run)`);
   } else {
     pass(`Shared context DB exists at ${dbPath}`);
@@ -27514,8 +27834,8 @@ async function runDoctor(options = {}) {
   }
   {
     const ageWarnings = [];
-    const npmrcPath = join13(homedir10(), ".npmrc");
-    if (existsSync14(npmrcPath)) {
+    const npmrcPath = join14(homedir10(), ".npmrc");
+    if (existsSync15(npmrcPath)) {
       try {
         const npmrc = readFileSync11(npmrcPath, "utf-8");
         for (const line of npmrc.split(`
@@ -27530,23 +27850,8 @@ async function runDoctor(options = {}) {
         }
       } catch {}
     }
-    const bunfigPath = join13(homedir10(), ".bunfig.toml");
-    if (existsSync14(bunfigPath)) {
-      try {
-        const bunfig = readFileSync11(bunfigPath, "utf-8");
-        for (const line of bunfig.split(`
-`)) {
-          const trimmed = line.trim();
-          if (trimmed.startsWith("#"))
-            continue;
-          if (/minimumReleaseAge\s*=/.test(trimmed)) {
-            ageWarnings.push(`~/.bunfig.toml has '${trimmed}'`);
-          }
-        }
-      } catch {}
-    }
     if (ageWarnings.length > 0) {
-      log.warn("Package manager min-release-age restriction detected — this can prevent OpenCode from installing the latest plugin version");
+      log.warn("npm min-release-age restriction detected — this can prevent OpenCode from installing the latest plugin version");
       for (const w of ageWarnings) {
         log.info(`  ${w}`);
       }
@@ -27555,20 +27860,20 @@ async function runDoctor(options = {}) {
       issues++;
     }
   }
-  const logPath = join13(tmpdir4(), "magic-context.log");
-  if (existsSync14(logPath)) {
+  const logPath = join14(tmpdir4(), "magic-context.log");
+  if (existsSync15(logPath)) {
     const logStat = statSync3(logPath);
     const sizeKb = (logStat.size / 1024).toFixed(0);
     log.info(`Log file: ${logPath} (${sizeKb} KB)`);
   } else {
     log.info(`Log file: ${logPath} (not yet created)`);
   }
-  const historianDumpDir = join13(tmpdir4(), "magic-context-historian");
-  if (existsSync14(historianDumpDir)) {
+  const historianDumpDir = join14(tmpdir4(), "magic-context-historian");
+  if (existsSync15(historianDumpDir)) {
     try {
       const dumps = readdirSync3(historianDumpDir).filter((f) => f.endsWith(".xml")).map((f) => ({
         name: f,
-        mtime: statSync3(join13(historianDumpDir, f)).mtimeMs
+        mtime: statSync3(join14(historianDumpDir, f)).mtimeMs
       })).sort((a, b) => b.mtime - a.mtime);
       if (dumps.length > 0) {
         warn(`Historian debug dumps: ${dumps.length} file(s) in ${historianDumpDir}`);
@@ -28005,7 +28310,7 @@ var Tokenizer = class {
     return this.encode(input).length;
   }
 }, NO_RANK = 4294967295, textEncoder, textDecoder, src_default;
-var init_dist3 = __esm(() => {
+var init_dist4 = __esm(() => {
   textEncoder = new TextEncoder;
   textDecoder = new TextDecoder("utf-8");
   src_default = Tokenizer;
@@ -160099,7 +160404,7 @@ var init_claude = __esm(() => {
 // ../plugin/src/hooks/magic-context/read-session-formatting.ts
 var tokenizer;
 var init_read_session_formatting = __esm(() => {
-  init_dist3();
+  init_dist4();
   init_claude();
   tokenizer = new src_default(exports_claude);
 });
@@ -160114,18 +160419,77 @@ var init_tag_part_guards = __esm(() => {
   init_tag_content_primitives();
 });
 
+// ../plugin/src/shared/record-type-guard.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../plugin/src/hooks/magic-context/tool-drop-target.ts
+function hasMeaningfulPart(part) {
+  if (!isRecord2(part))
+    return false;
+  const type = part.type;
+  if (type === "text") {
+    return typeof part.text === "string" && part.text.trim().length > 0;
+  }
+  if (typeof type !== "string")
+    return false;
+  if (IGNORE_PART_TYPES.has(type))
+    return false;
+  return true;
+}
+
+class ToolMutationBatch {
+  partsToRemove = new Set;
+  affectedMessages = new Set;
+  messages;
+  constructor(messages) {
+    this.messages = messages;
+  }
+  markForRemoval(occurrence) {
+    this.partsToRemove.add(occurrence.part);
+    this.affectedMessages.add(occurrence.message);
+  }
+  finalize() {
+    if (this.partsToRemove.size === 0)
+      return;
+    for (const message of this.affectedMessages) {
+      message.parts = message.parts.filter((p) => !this.partsToRemove.has(p));
+    }
+    for (let i = this.messages.length - 1;i >= 0; i -= 1) {
+      if (!this.messages[i].parts.some(hasMeaningfulPart)) {
+        this.messages.splice(i, 1);
+      }
+    }
+    this.partsToRemove.clear();
+    this.affectedMessages.clear();
+  }
+}
+var IGNORE_PART_TYPES;
+var init_tool_drop_target = __esm(() => {
+  IGNORE_PART_TYPES = new Set([
+    "thinking",
+    "reasoning",
+    "redacted_thinking",
+    "meta",
+    "step-start",
+    "step-finish"
+  ]);
+});
+
 // ../plugin/src/hooks/magic-context/read-session-chunk.ts
 var sessionProviders;
 var init_read_session_chunk = __esm(async () => {
   init_read_session_formatting();
   init_tag_part_guards();
+  init_tool_drop_target();
   init_read_session_formatting();
   await init_read_session_db();
   sessionProviders = new Map;
 });
 
 // ../plugin/src/features/magic-context/message-index.ts
-var lastIndexedStatements, insertMessageStatements, upsertIndexStatements, deleteFtsStatements, deleteIndexStatements, countIndexedMessageStatements;
+var lastIndexedStatements, insertMessageStatements, upsertIndexStatements, deleteFtsStatements, deleteIndexStatements, countIndexedMessageStatements, indexedMessageIdStatements;
 var init_message_index = __esm(async () => {
   init_compression_depth_storage();
   await init_read_session_chunk();
@@ -160135,6 +160499,7 @@ var init_message_index = __esm(async () => {
   deleteFtsStatements = new WeakMap;
   deleteIndexStatements = new WeakMap;
   countIndexedMessageStatements = new WeakMap;
+  indexedMessageIdStatements = new WeakMap;
 });
 
 // ../plugin/src/shared/error-message.ts
@@ -160156,22 +160521,51 @@ function getCurrentVersion(db) {
   const row = db.prepare("SELECT MAX(version) as version FROM schema_migrations").get();
   return row?.version ?? 0;
 }
+function isSiblingMigrationConflict(error48, version2) {
+  if (!(error48 instanceof Error))
+    return false;
+  const code = error48.code;
+  if (code !== "SQLITE_CONSTRAINT_PRIMARYKEY" && code !== "SQLITE_CONSTRAINT_UNIQUE") {
+    return false;
+  }
+  const msg = error48.message;
+  if (!msg.includes("schema_migrations"))
+    return false;
+  if (!msg.toLowerCase().includes("version"))
+    return false;
+  return true;
+}
 function runMigrations(db) {
   ensureMigrationsTable(db);
-  const currentVersion = getCurrentVersion(db);
-  const pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
+  let currentVersion = getCurrentVersion(db);
+  let pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
   if (pendingMigrations.length === 0) {
     return;
   }
   log2(`[migrations] current schema version: ${currentVersion}, applying ${pendingMigrations.length} migration(s)`);
-  for (const migration of pendingMigrations) {
+  let migrationIndex = 0;
+  while (migrationIndex < pendingMigrations.length) {
+    const migration = pendingMigrations[migrationIndex];
     try {
       db.transaction(() => {
         migration.up(db);
         db.prepare("INSERT INTO schema_migrations (version, description, applied_at) VALUES (?, ?, ?)").run(migration.version, migration.description, Date.now());
       })();
       log2(`[migrations] applied v${migration.version}: ${migration.description}`);
+      migrationIndex += 1;
     } catch (error48) {
+      if (isSiblingMigrationConflict(error48, migration.version)) {
+        log2(`[migrations] v${migration.version} already applied by sibling instance — resuming with re-read version`);
+        const reReadVersion = getCurrentVersion(db);
+        if (reReadVersion <= currentVersion) {
+          log2(`[migrations] FAILED v${migration.version}: sibling-conflict shape but version not advanced (${reReadVersion} <= ${currentVersion}) — failing closed`);
+          throw new Error(`Migration v${migration.version} failed: sibling conflict reported but version did not advance. Database may need manual repair.`);
+        }
+        currentVersion = reReadVersion;
+        pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
+        migrationIndex = 0;
+        continue;
+      }
       log2(`[migrations] FAILED v${migration.version}: ${migration.description} — ${error48 instanceof Error ? error48.message : String(error48)}`);
       throw new Error(`Migration v${migration.version} failed: ${error48 instanceof Error ? error48.message : String(error48)}. Database may need manual repair.`);
     }
@@ -160383,30 +160777,361 @@ var init_migrations = __esm(async () => {
           db.exec("ALTER TABLE notes ADD COLUMN harness TEXT NOT NULL DEFAULT 'opencode'");
         }
       }
+    },
+    {
+      version: 8,
+      description: "Add partial indexes on tags(session_id, tag_number) for active and dropped",
+      up: (db) => {
+        db.exec(`
+                CREATE INDEX IF NOT EXISTS idx_tags_active_session_tag_number
+                ON tags(session_id, tag_number)
+                WHERE status = 'active';
+
+                CREATE INDEX IF NOT EXISTS idx_tags_dropped_session_tag_number
+                ON tags(session_id, tag_number)
+                WHERE status = 'dropped';
+            `);
+        db.exec("ANALYZE tags;");
+      }
+    },
+    {
+      version: 9,
+      description: "Persist tool_definition_measurements across plugin restarts",
+      up: (db) => {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS tool_definition_measurements (
+                    provider_id TEXT NOT NULL,
+                    model_id TEXT NOT NULL,
+                    agent_name TEXT NOT NULL,
+                    tool_id TEXT NOT NULL,
+                    token_count INTEGER NOT NULL,
+                    recorded_at INTEGER NOT NULL,
+                    PRIMARY KEY (provider_id, model_id, agent_name, tool_id)
+                );
+            `);
+      }
+    },
+    {
+      version: 10,
+      description: "Add tool_owner_message_id column to tags + composite identity indexes",
+      up: (db) => {
+        const cols = db.prepare("PRAGMA table_info(tags)").all();
+        if (!cols.some((c) => c.name === "tool_owner_message_id")) {
+          db.exec("ALTER TABLE tags ADD COLUMN tool_owner_message_id TEXT DEFAULT NULL");
+        }
+        db.exec(`
+                CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_tool_composite
+                ON tags(session_id, message_id, tool_owner_message_id)
+                WHERE type = 'tool' AND tool_owner_message_id IS NOT NULL;
+
+                CREATE INDEX IF NOT EXISTS idx_tags_tool_null_owner
+                ON tags(session_id, message_id)
+                WHERE type = 'tool' AND tool_owner_message_id IS NULL;
+            `);
+      }
     }
   ];
 });
 
+// ../plugin/src/features/magic-context/tool-definition-tokens.ts
+function keyFor(providerID, modelID, agentName) {
+  const agent = agentName && agentName.length > 0 ? agentName : "default";
+  return `${providerID}/${modelID}/${agent}`;
+}
+function setDatabase(db) {
+  persistenceDb = db;
+}
+function loadToolDefinitionMeasurements(db) {
+  let rows = [];
+  try {
+    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count FROM tool_definition_measurements").all();
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const key = keyFor(row.provider_id, row.model_id, row.agent_name);
+    let inner = measurements.get(key);
+    if (!inner) {
+      inner = new Map;
+      measurements.set(key, inner);
+    }
+    inner.set(row.tool_id, row.token_count);
+  }
+}
+var measurements, persistenceDb = null;
+var init_tool_definition_tokens = __esm(() => {
+  init_read_session_formatting();
+  measurements = new Map;
+});
+
+// ../plugin/src/features/magic-context/tool-owner-backfill.ts
+import { existsSync as existsSync16 } from "node:fs";
+import { join as join15 } from "node:path";
+function resolveOpencodeDbPath() {
+  return join15(getDataDir(), "opencode", "opencode.db");
+}
+function ensureBackfillStateTable(db) {
+  db.exec(`
+        CREATE TABLE IF NOT EXISTS tool_owner_backfill_state (
+            session_id TEXT PRIMARY KEY,
+            status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'completed', 'skipped')),
+            started_at INTEGER,
+            lease_expires_at INTEGER,
+            completed_at INTEGER,
+            last_error TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_tool_owner_backfill_state_status
+        ON tool_owner_backfill_state(status);
+    `);
+}
+function runToolOwnerBackfill(db) {
+  const startedAt = performance.now();
+  ensureBackfillStateTable(db);
+  const result = {
+    sessionsProcessed: 0,
+    sessionsSkippedNoOcDb: 0,
+    sessionsSkippedNoMatches: 0,
+    sessionsCompleted: 0,
+    sessionsBlockedByLease: 0,
+    sessionsErrored: 0,
+    rowsUpdated: 0,
+    rowsLeftNull: 0,
+    durationMs: 0
+  };
+  if (!isToolOwnerBackfillNeeded(db)) {
+    result.durationMs = performance.now() - startedAt;
+    return result;
+  }
+  const opencodeDbPath = resolveOpencodeDbPath();
+  if (!existsSync16(opencodeDbPath)) {
+    log2(`[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");
+    result.durationMs = performance.now() - startedAt;
+    return result;
+  }
+  db.exec(`ATTACH '${opencodeDbPath}' AS oc_backfill`);
+  try {
+    backfillToolOwnersInChunks(db, result);
+  } finally {
+    try {
+      db.exec("DETACH DATABASE oc_backfill");
+    } catch (error48) {
+      log2(`[backfill] failed to detach oc_backfill database: ${error48 instanceof Error ? error48.message : String(error48)}`);
+    }
+  }
+  result.durationMs = performance.now() - startedAt;
+  log2(`[backfill] sessions=${result.sessionsProcessed} completed=${result.sessionsCompleted} skipped_no_oc=${result.sessionsSkippedNoOcDb} skipped_no_matches=${result.sessionsSkippedNoMatches} blocked_by_lease=${result.sessionsBlockedByLease} errored=${result.sessionsErrored} rows_updated=${result.rowsUpdated} rows_left_null=${result.rowsLeftNull} duration_ms=${Math.round(result.durationMs)}`);
+  return result;
+}
+function isToolOwnerBackfillNeeded(db) {
+  ensureBackfillStateTable(db);
+  const row = db.prepare(`SELECT 1 AS hit
+             FROM tags
+             WHERE type = 'tool' AND tool_owner_message_id IS NULL
+               AND NOT EXISTS (
+                   SELECT 1 FROM tool_owner_backfill_state s
+                   WHERE s.session_id = tags.session_id
+                     AND s.status IN ('completed', 'skipped')
+               )
+             LIMIT 1`).get();
+  return row !== null && row !== undefined;
+}
+function markAllUnbackfilledSessionsSkipped(db) {
+  const now = Date.now();
+  db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, started_at, completed_at, last_error)
+         SELECT DISTINCT session_id, 'skipped', NULL, ?, NULL
+         FROM tags
+         WHERE type = 'tool' AND tool_owner_message_id IS NULL
+         ON CONFLICT(session_id) DO UPDATE SET
+             status = 'skipped',
+             completed_at = excluded.completed_at,
+             last_error = NULL
+         WHERE tool_owner_backfill_state.status NOT IN ('completed', 'running')`).run(now);
+}
+function countSessionsByStatus(db, status) {
+  const row = db.prepare("SELECT COUNT(*) AS c FROM tool_owner_backfill_state WHERE status = ?").get(status);
+  return row.c;
+}
+function acquireSessionLease(db, sessionId, now) {
+  const expiresAt = now + LEASE_DURATION_MS;
+  const result = db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, started_at, lease_expires_at)
+             VALUES (?, 'running', ?, ?)
+             ON CONFLICT(session_id) DO UPDATE SET
+                 status = 'running',
+                 started_at = excluded.started_at,
+                 lease_expires_at = excluded.lease_expires_at,
+                 last_error = NULL
+             WHERE tool_owner_backfill_state.status IN ('pending', 'skipped')
+                OR (tool_owner_backfill_state.status = 'running'
+                    AND tool_owner_backfill_state.lease_expires_at < ?)`).run(sessionId, now, expiresAt, now);
+  return (result.changes ?? 0) === 1;
+}
+function renewSessionLease(db, sessionId, now) {
+  const expiresAt = now + LEASE_DURATION_MS;
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET lease_expires_at = ?
+         WHERE session_id = ? AND status = 'running'`).run(expiresAt, sessionId);
+}
+function markSessionCompleted(db, sessionId, now) {
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET status = 'completed', completed_at = ?, lease_expires_at = NULL, last_error = NULL
+         WHERE session_id = ?`).run(now, sessionId);
+}
+function markSessionSkipped(db, sessionId, now, reason) {
+  db.prepare(`INSERT INTO tool_owner_backfill_state(session_id, status, completed_at, last_error)
+         VALUES (?, 'skipped', ?, ?)
+         ON CONFLICT(session_id) DO UPDATE SET
+             status = 'skipped',
+             completed_at = excluded.completed_at,
+             last_error = excluded.last_error,
+             lease_expires_at = NULL`).run(sessionId, now, reason);
+}
+function markSessionErrored(db, sessionId, error48) {
+  const message = error48 instanceof Error ? error48.message : String(error48);
+  db.prepare(`UPDATE tool_owner_backfill_state
+         SET last_error = ?, lease_expires_at = NULL
+         WHERE session_id = ?`).run(message, sessionId);
+}
+function getSessionsNeedingBackfill(db) {
+  const rows = db.prepare(`SELECT DISTINCT t.session_id
+             FROM tags t
+             LEFT JOIN tool_owner_backfill_state s ON s.session_id = t.session_id
+             WHERE t.type = 'tool' AND t.tool_owner_message_id IS NULL
+               AND (s.status IS NULL OR s.status NOT IN ('completed', 'skipped'))
+             ORDER BY t.session_id ASC`).all();
+  return rows.map((r) => r.session_id);
+}
+function buildSessionOwnerMap(db, sessionId) {
+  const rows = db.prepare(`SELECT
+                COALESCE(
+                    CASE WHEN json_extract(p.data, '$.type') = 'tool_use'
+                        THEN json_extract(p.data, '$.id')
+                    END,
+                    json_extract(p.data, '$.callID')
+                ) AS callid,
+                m.id AS owner_id,
+                m.time_created AS owner_t_created,
+                p.id AS part_id,
+                p.time_created AS part_t_created
+             FROM oc_backfill.message m
+             INNER JOIN oc_backfill.part p ON p.message_id = m.id
+             WHERE m.session_id = ?
+               AND json_extract(m.data, '$.role') = 'assistant'
+               AND (
+                   (json_extract(p.data, '$.type') IN ('tool', 'tool-invocation')
+                       AND json_extract(p.data, '$.callID') IS NOT NULL)
+                   OR (json_extract(p.data, '$.type') = 'tool_use'
+                       AND json_extract(p.data, '$.id') IS NOT NULL)
+               )
+             ORDER BY
+                 m.time_created ASC,
+                 m.id ASC,
+                 p.time_created ASC,
+                 p.id ASC`).all(sessionId);
+  const oldestByCallId = new Map;
+  for (const r of rows) {
+    if (typeof r.callid !== "string" || r.callid.length === 0)
+      continue;
+    if (!oldestByCallId.has(r.callid)) {
+      oldestByCallId.set(r.callid, r.owner_id);
+    }
+  }
+  return oldestByCallId;
+}
+function applyOwnersForSession(db, sessionId, ownersByCallId) {
+  if (ownersByCallId.size === 0) {
+    const leftNull = db.prepare(`SELECT COUNT(*) AS c FROM tags
+                     WHERE session_id = ? AND type = 'tool'
+                       AND tool_owner_message_id IS NULL`).get(sessionId).c;
+    return { rowsUpdated: 0, rowsLeftNull: leftNull };
+  }
+  const findOrphanStmt = db.prepare(`SELECT id FROM tags
+         WHERE session_id = ? AND message_id = ? AND type = 'tool'
+           AND tool_owner_message_id IS NULL
+         ORDER BY tag_number ASC
+         LIMIT 1`);
+  const updateRowStmt = db.prepare(`UPDATE tags
+         SET tool_owner_message_id = ?
+         WHERE id = ? AND tool_owner_message_id IS NULL`);
+  let rowsUpdated = 0;
+  db.transaction(() => {
+    for (const [callId, ownerId] of ownersByCallId) {
+      const orphan = findOrphanStmt.get(sessionId, callId);
+      if (!orphan)
+        continue;
+      const result = updateRowStmt.run(ownerId, orphan.id);
+      rowsUpdated += result.changes ?? 0;
+    }
+  })();
+  const rowsLeftNull = db.prepare(`SELECT COUNT(*) AS c FROM tags
+                 WHERE session_id = ? AND type = 'tool'
+                   AND tool_owner_message_id IS NULL`).get(sessionId).c;
+  return { rowsUpdated, rowsLeftNull };
+}
+function backfillToolOwnersInChunks(db, result) {
+  const sessionIds = getSessionsNeedingBackfill(db);
+  let lastRenewedAt = Date.now();
+  for (const sessionId of sessionIds) {
+    const now = Date.now();
+    result.sessionsProcessed += 1;
+    const acquired = acquireSessionLease(db, sessionId, now);
+    if (!acquired) {
+      result.sessionsBlockedByLease += 1;
+      continue;
+    }
+    try {
+      const owners = buildSessionOwnerMap(db, sessionId);
+      const { rowsUpdated, rowsLeftNull } = applyOwnersForSession(db, sessionId, owners);
+      result.rowsUpdated += rowsUpdated;
+      result.rowsLeftNull += rowsLeftNull;
+      if (owners.size === 0) {
+        markSessionSkipped(db, sessionId, Date.now(), "no_oc_matches");
+        result.sessionsSkippedNoMatches += 1;
+      } else {
+        markSessionCompleted(db, sessionId, Date.now());
+        result.sessionsCompleted += 1;
+      }
+    } catch (error48) {
+      log2(`[backfill] session=${sessionId} errored: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      markSessionErrored(db, sessionId, error48);
+      result.sessionsErrored += 1;
+    }
+    const sinceRenew = Date.now() - lastRenewedAt;
+    if (sinceRenew > LEASE_RENEWAL_MS) {
+      renewSessionLease(db, sessionId, Date.now());
+      lastRenewedAt = Date.now();
+    }
+  }
+}
+var LEASE_DURATION_MS, LEASE_RENEWAL_MS;
+var init_tool_owner_backfill = __esm(() => {
+  init_data_path();
+  init_logger();
+  LEASE_DURATION_MS = 5 * 60 * 1000;
+  LEASE_RENEWAL_MS = 60 * 1000;
+});
+
 // ../plugin/src/features/magic-context/storage-db.ts
-import { copyFileSync, cpSync, existsSync as existsSync15, mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join14 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync17, mkdirSync as mkdirSync7 } from "node:fs";
+import { join as join16 } from "node:path";
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join14(dbDir, "context.db") };
+  return { dbDir, dbPath: join16(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync15(targetDbPath))
+  if (existsSync17(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join14(legacyDir, "context.db");
-  if (!existsSync15(legacyDbPath))
+  const legacyDbPath = join16(legacyDir, "context.db");
+  if (!existsSync17(legacyDbPath))
     return;
   log2(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
-  mkdirSync6(targetDbDir, { recursive: true });
+  mkdirSync7(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join14(targetDbDir, `context.db${suffix}`);
-    if (existsSync15(src)) {
+    const dst = join16(targetDbDir, `context.db${suffix}`);
+    if (existsSync17(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error48) {
@@ -160414,9 +161139,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join14(legacyDir, "models");
-  const targetModelsDir = join14(targetDbDir, "models");
-  if (existsSync15(legacyModelsDir) && !existsSync15(targetModelsDir)) {
+  const legacyModelsDir = join16(legacyDir, "models");
+  const targetModelsDir = join16(targetDbDir, "models");
+  if (existsSync17(legacyModelsDir) && !existsSync17(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error48) {
@@ -160702,6 +161427,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "tags", "tool_name", "TEXT");
   ensureColumn(db, "tags", "input_byte_size", "INTEGER DEFAULT 0");
   ensureColumn(db, "tags", "caveman_depth", "INTEGER DEFAULT 0");
+  ensureColumn(db, "tags", "tool_owner_message_id", "TEXT DEFAULT NULL");
   ensureColumn(db, "session_meta", "system_prompt_tokens", "INTEGER DEFAULT 0");
   ensureColumn(db, "session_meta", "compaction_marker_state", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "key_files", "TEXT DEFAULT ''");
@@ -160796,10 +161522,17 @@ function openDatabase() {
   }
   try {
     migrateLegacyStorageIfNeeded(dbPath, dbDir);
-    mkdirSync6(dbDir, { recursive: true });
+    mkdirSync7(dbDir, { recursive: true });
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
+    try {
+      runToolOwnerBackfill(db);
+    } catch (error48) {
+      log2(`[magic-context] tool-owner backfill failed (continuing with lazy adoption fallback): ${getErrorMessage(error48)}`);
+    }
+    setDatabase(db);
+    loadToolDefinitionMeasurements(db);
     databases.set(dbPath, db);
     persistenceByDatabase.set(db, true);
     persistenceErrorByDatabase.delete(db);
@@ -160828,6 +161561,8 @@ var databases, persistenceByDatabase, persistenceErrorByDatabase;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
+  init_tool_definition_tokens();
+  init_tool_owner_backfill();
   await __promiseAll([
     init_sqlite(),
     init_migrations()
@@ -160892,7 +161627,7 @@ var init_storage_ops = __esm(() => {
 var init_storage_source = () => {};
 
 // ../plugin/src/features/magic-context/storage-tags.ts
-var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements;
+var insertTagStatements, updateTagStatusStatements, updateTagDropModeStatements, updateTagMessageIdStatements, getTagNumbersByMessageIdStatements, deleteTagsByMessageIdStatements, getMaxTagNumberBySessionStatements, getTagNumberByMessageIdStatements, updateTagByteSizeStatements, updateTagInputByteSizeStatements, getOwnerScopedToolTagNumbersStatements, getActiveTagsBySessionStatements, getMaxDroppedTagNumberStatements, getToolTagNumberByOwnerStatements, getNullOwnerToolTagStatements, adoptNullOwnerToolTagStatements, deleteToolTagsByOwnerStatements;
 var init_storage_tags = __esm(() => {
   insertTagStatements = new WeakMap;
   updateTagStatusStatements = new WeakMap;
@@ -160904,6 +161639,13 @@ var init_storage_tags = __esm(() => {
   getTagNumberByMessageIdStatements = new WeakMap;
   updateTagByteSizeStatements = new WeakMap;
   updateTagInputByteSizeStatements = new WeakMap;
+  getOwnerScopedToolTagNumbersStatements = new WeakMap;
+  getActiveTagsBySessionStatements = new WeakMap;
+  getMaxDroppedTagNumberStatements = new WeakMap;
+  getToolTagNumberByOwnerStatements = new WeakMap;
+  getNullOwnerToolTagStatements = new WeakMap;
+  adoptNullOwnerToolTagStatements = new WeakMap;
+  deleteToolTagsByOwnerStatements = new WeakMap;
 });
 
 // ../plugin/src/features/magic-context/storage.ts
@@ -160922,42 +161664,42 @@ var init_storage = __esm(async () => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync16, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 function getProjectConfigPaths(cwd) {
-  const basePath = join15(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join17(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
   const home = process.env.HOME ?? homedir11();
-  const basePath = join15(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const basePath = join17(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path3) => existsSync16(path3));
+  return paths.find((path4) => existsSync18(path4));
 }
-function loadConfigFile2(path3, scope) {
+function loadConfigFile2(path4, scope) {
   try {
-    const rawText = readFileSync12(path3, "utf-8");
+    const rawText = readFileSync12(path4, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path3
+      configPath: path4
     });
     return {
-      path: path3,
+      path: path4,
       scope,
       config: import_comment_json8.parse(substituted.text),
-      warnings: substituted.warnings.map((warning) => `${path3}: ${warning}`)
+      warnings: substituted.warnings.map((warning) => `${path4}: ${warning}`)
     };
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
     return {
-      path: path3,
+      path: path4,
       scope,
       config: {},
       warnings: [
-        `${path3}: failed to load config: ${message}; using defaults for this file.`
+        `${path4}: failed to load config: ${message}; using defaults for this file.`
       ]
     };
   }
@@ -161069,12 +161811,12 @@ var init_config2 = __esm(() => {
 
 // src/lib/diagnostics-pi.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync13, statSync as statSync4 } from "node:fs";
-import { createRequire as createRequire4 } from "node:module";
+import { existsSync as existsSync19, readFileSync as readFileSync13, statSync as statSync4 } from "node:fs";
+import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir12, tmpdir as tmpdir5, userInfo as userInfo3 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join18 } from "node:path";
 function getSelfVersion3() {
-  const req = createRequire4(import.meta.url);
+  const req = createRequire5(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
     try {
       const pkg = req(relPath);
@@ -161085,9 +161827,9 @@ function getSelfVersion3() {
   }
   return "unknown";
 }
-function fileSize2(path3) {
+function fileSize2(path4) {
   try {
-    return existsSync17(path3) ? statSync4(path3).size : 0;
+    return existsSync19(path4) ? statSync4(path4).size : 0;
   } catch {
     return 0;
   }
@@ -161136,12 +161878,12 @@ function sanitizeValue2(value, key = "") {
   }
   return value;
 }
-function readJsonc3(path3) {
-  if (!existsSync17(path3))
+function readJsonc3(path4) {
+  if (!existsSync19(path4))
     return { value: {} };
   try {
     return {
-      value: import_comment_json9.parse(readFileSync13(path3, "utf-8"))
+      value: import_comment_json9.parse(readFileSync13(path4, "utf-8"))
     };
   } catch (error48) {
     return {
@@ -161151,13 +161893,13 @@ function readJsonc3(path3) {
   }
 }
 function getProjectConfigPath(cwd) {
-  return join16(cwd, ".pi", "magic-context.jsonc");
+  return join18(cwd, ".pi", "magic-context.jsonc");
 }
-function readConfigDiagnostic(path3) {
-  const parsed = readJsonc3(path3);
+function readConfigDiagnostic(path4) {
+  const parsed = readJsonc3(path4);
   return {
-    path: path3,
-    exists: existsSync17(path3),
+    path: path4,
+    exists: existsSync19(path4),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -161177,9 +161919,9 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const projectConfigPath = getProjectConfigPath(cwd);
   const loaded = loadPiConfig({ cwd });
   const storageDirPath = getMagicContextStorageDir();
-  const dbPath = join16(storageDirPath, "context.db");
-  const logPath = join16(tmpdir5(), "magic-context.log");
-  const logFileSize = existsSync17(logPath) ? statSync4(logPath).size : 0;
+  const dbPath = join18(storageDirPath, "context.db");
+  const logPath = join18(tmpdir5(), "magic-context.log");
+  const logFileSize = existsSync19(logPath) ? statSync4(logPath).size : 0;
   const otherPiExtensions = packages.filter((entry) => !hasMagicContextPackage([entry]));
   return {
     timestamp: new Date().toISOString(),
@@ -161192,7 +161934,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync17(settingsPath),
+      exists: existsSync19(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasMagicContextPackage(packages),
       packages: packages.map(sanitizeString2)
@@ -161208,7 +161950,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     loadWarnings: loaded.warnings.map(sanitizeString2),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync17(storageDirPath),
+      exists: existsSync19(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -161217,7 +161959,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     },
     logFile: {
       path: logPath,
-      exists: existsSync17(logPath),
+      exists: existsSync19(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     }
   };
@@ -161271,7 +162013,7 @@ function renderDiagnosticsMarkdown2(report) {
     "```",
     "",
     "### Loaded config paths",
-    report.loadedConfigPaths.length === 0 ? "_No config files loaded; defaults are in use._" : report.loadedConfigPaths.map((path3) => `- ${path3}`).join(`
+    report.loadedConfigPaths.length === 0 ? "_No config files loaded; defaults are in use._" : report.loadedConfigPaths.map((path4) => `- ${path4}`).join(`
 `),
     "",
     "### Config load warnings",
@@ -161306,8 +162048,8 @@ var init_diagnostics_pi = __esm(() => {
 });
 
 // src/lib/logs-pi.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join17 } from "node:path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join19 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
 }
@@ -161351,10 +162093,10 @@ async function bundleIssueReport2(report, description, title, options = {}) {
   ].join(`
 `);
   const cwd = options.cwd ?? process.cwd();
-  const path3 = join17(cwd, `magic-context-pi-issue-${formatTimestamp2(options.now ?? new Date)}.md`);
-  writeFileSync10(path3, `${bodyMarkdown}
+  const path4 = join19(cwd, `magic-context-pi-issue-${formatTimestamp2(options.now ?? new Date)}.md`);
+  writeFileSync11(path4, `${bodyMarkdown}
 `);
-  return { path: path3, bodyMarkdown };
+  return { path: path4, bodyMarkdown };
 }
 var init_logs_pi = __esm(() => {
   init_diagnostics_pi();
@@ -161363,17 +162105,17 @@ var init_logs_pi = __esm(() => {
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync3, spawnSync as spawnSync3 } from "node:child_process";
 import {
-  existsSync as existsSync18,
-  mkdirSync as mkdirSync7,
+  existsSync as existsSync20,
+  mkdirSync as mkdirSync8,
   readdirSync as readdirSync4,
   readFileSync as readFileSync15,
   rmSync as rmSync2,
   statSync as statSync5,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
-import { createRequire as createRequire5 } from "node:module";
+import { createRequire as createRequire6 } from "node:module";
 import { homedir as homedir13, tmpdir as tmpdir6 } from "node:os";
-import { dirname as dirname8, join as join18 } from "node:path";
+import { dirname as dirname9, join as join20 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS,
@@ -161394,7 +162136,7 @@ function printDoctorHelp() {
   console.log("");
 }
 function selfVersion() {
-  const req = createRequire5(import.meta.url);
+  const req = createRequire6(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
     try {
       const pkg = req(relPath);
@@ -161457,10 +162199,10 @@ function summarize(results) {
     fail: results.filter((result) => result.status === "fail").length
   };
 }
-function readJsonc4(path3) {
+function readJsonc4(path4) {
   try {
     return {
-      value: import_comment_json10.parse(readFileSync15(path3, "utf-8"))
+      value: import_comment_json10.parse(readFileSync15(path4, "utf-8"))
     };
   } catch (error48) {
     return {
@@ -161476,16 +162218,16 @@ function hasPiPackage(packages) {
   return packages.some((entry) => entry === PI_PACKAGE_SOURCE || entry === PACKAGE_NAME2 || entry.includes("pi-magic-context"));
 }
 function projectConfigPath(cwd) {
-  return join18(cwd, ".pi", "magic-context.jsonc");
+  return join20(cwd, ".pi", "magic-context.jsonc");
 }
-function readConfigForEmbedding(path3) {
-  if (!existsSync18(path3))
+function readConfigForEmbedding(path4) {
+  if (!existsSync20(path4))
     return null;
   try {
-    const rawText = readFileSync15(path3, "utf-8");
+    const rawText = readFileSync15(path4, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path3
+      configPath: path4
     });
     return import_comment_json10.parse(substituted.text);
   } catch {
@@ -161541,51 +162283,51 @@ function countTable(db, table) {
 }
 function cacheRoots() {
   const home = homedir13();
-  const cacheHome = process.env.XDG_CACHE_HOME || join18(home, ".cache");
+  const cacheHome = process.env.XDG_CACHE_HOME || join20(home, ".cache");
   return [
-    join18(home, ".pi", "cache", "extensions"),
-    join18(home, ".pi", "cache", "packages"),
-    join18(cacheHome, "pi", "extensions"),
-    join18(cacheHome, "pi", "packages"),
-    join18(getPiAgentConfigDir(), "cache", "extensions")
+    join20(home, ".pi", "cache", "extensions"),
+    join20(home, ".pi", "cache", "packages"),
+    join20(cacheHome, "pi", "extensions"),
+    join20(cacheHome, "pi", "packages"),
+    join20(getPiAgentConfigDir(), "cache", "extensions")
   ];
 }
 function findPiMagicContextCacheDirs(self, force = false) {
   const found = new Map;
-  const visit = (path3, depth) => {
-    if (depth < 0 || !existsSync18(path3))
+  const visit = (path4, depth) => {
+    if (depth < 0 || !existsSync20(path4))
       return;
     let stat;
     try {
-      stat = statSync5(path3);
+      stat = statSync5(path4);
     } catch {
       return;
     }
     if (!stat.isDirectory())
       return;
-    const packageJson = join18(path3, "package.json");
-    if (existsSync18(packageJson)) {
+    const packageJson = join20(path4, "package.json");
+    if (existsSync20(packageJson)) {
       try {
         const pkg = JSON.parse(readFileSync15(packageJson, "utf-8"));
         const name2 = typeof pkg.name === "string" ? pkg.name : "";
         const version2 = typeof pkg.version === "string" ? pkg.version : undefined;
-        if (name2 === PACKAGE_NAME2 || path3.includes("pi-magic-context")) {
+        if (name2 === PACKAGE_NAME2 || path4.includes("pi-magic-context")) {
           if (force || !version2 || version2 !== self)
-            found.set(path3, { path: path3, version: version2 });
+            found.set(path4, { path: path4, version: version2 });
         }
       } catch {
-        if (path3.includes("pi-magic-context"))
-          found.set(path3, { path: path3 });
+        if (path4.includes("pi-magic-context"))
+          found.set(path4, { path: path4 });
       }
     }
     let entries = [];
     try {
-      entries = readdirSync4(path3);
+      entries = readdirSync4(path4);
     } catch {
       return;
     }
     for (const entry of entries)
-      visit(join18(path3, entry), depth - 1);
+      visit(join20(path4, entry), depth - 1);
   };
   for (const root of cacheRoots())
     visit(root, 5);
@@ -161622,7 +162364,7 @@ async function runHealthChecks(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync18(settingsPath)) {
+  if (!existsSync20(settingsPath)) {
     add(results, "warn", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -161642,24 +162384,24 @@ async function runHealthChecks(options) {
   }
   const userConfigPath = getPiUserConfigPath();
   const projectPath = projectConfigPath(options.cwd);
-  for (const [label, path3, required2] of [
+  for (const [label, path4, required2] of [
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync18(path3)) {
+    if (!existsSync20(path4)) {
       if (required2) {
-        add(results, "warn", `No ${label} magic-context.jsonc found at ${path3}`);
+        add(results, "warn", `No ${label} magic-context.jsonc found at ${path4}`);
         repairPlan.writeUserConfig = true;
       } else {
-        add(results, "info", `No project Pi magic-context.jsonc found at ${path3}`);
+        add(results, "info", `No project Pi magic-context.jsonc found at ${path4}`);
       }
       continue;
     }
-    const parsed = readJsonc4(path3);
+    const parsed = readJsonc4(path4);
     if (parsed.error)
       add(results, "fail", `${label} magic-context.jsonc is invalid JSONC: ${parsed.error}`);
     else
-      add(results, "pass", `${label} magic-context.jsonc is valid JSONC: ${path3}`);
+      add(results, "pass", `${label} magic-context.jsonc is valid JSONC: ${path4}`);
   }
   const loadedConfig = loadPiConfig({ cwd: options.cwd });
   if (loadedConfig.warnings.length > 0) {
@@ -161679,8 +162421,8 @@ async function runHealthChecks(options) {
     add(results, "pass", `historian.model "${historianModel}" has thinking_level "${historianThinkingLevel}" configured`);
   }
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join18(storageDir, "context.db");
-  const existedBeforeOpen = existsSync18(dbPath);
+  const dbPath = join20(storageDir, "context.db");
+  const existedBeforeOpen = existsSync20(dbPath);
   if (existedBeforeOpen)
     add(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -161756,8 +162498,8 @@ async function runHealthChecks(options) {
   } else {
     add(results, "pass", "Pi extension cache clean (no stale cached package found)");
   }
-  const logPath = join18(tmpdir6(), "magic-context.log");
-  if (existsSync18(logPath)) {
+  const logPath = join20(tmpdir6(), "magic-context.log");
+  if (existsSync20(logPath)) {
     const stat = statSync5(logPath);
     const sizeKb = (stat.size / 1024).toFixed(0);
     const lines = readFileSync15(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -161766,10 +162508,10 @@ async function runHealthChecks(options) {
   } else {
     add(results, "info", `No plugin log file yet at ${logPath}`);
   }
-  const historianDumpDir = join18(tmpdir6(), "magic-context-historian");
-  if (existsSync18(historianDumpDir)) {
+  const historianDumpDir = join20(tmpdir6(), "magic-context-historian");
+  if (existsSync20(historianDumpDir)) {
     try {
-      const dumps = readdirSync4(historianDumpDir).filter((f) => f.endsWith(".xml")).map((f) => ({ name: f, mtime: statSync5(join18(historianDumpDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+      const dumps = readdirSync4(historianDumpDir).filter((f) => f.endsWith(".xml")).map((f) => ({ name: f, mtime: statSync5(join20(historianDumpDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
       if (dumps.length > 0) {
         add(results, "warn", `Historian debug dumps: ${dumps.length} file(s) in ${historianDumpDir}`);
         for (const dump of dumps.slice(0, 3)) {
@@ -161789,13 +162531,13 @@ async function runHealthChecks(options) {
   }
   return { results, repairPlan, ...summarize(results) };
 }
-function writeDefaultMagicContextConfig(path3) {
-  mkdirSync7(dirname8(path3), { recursive: true });
+function writeDefaultMagicContextConfig(path4) {
+  mkdirSync8(dirname9(path4), { recursive: true });
   const config2 = {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
   };
-  writeFileSync11(path3, `${import_comment_json10.stringify(config2, null, 2)}
+  writeFileSync12(path4, `${import_comment_json10.stringify(config2, null, 2)}
 `);
 }
 function repair(plan, prompts) {
@@ -161812,7 +162554,7 @@ function repair(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync18(configPath)) {
+    if (!existsSync20(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -161822,13 +162564,13 @@ function repair(plan, prompts) {
       }
     }
   }
-  for (const path3 of plan.clearCachePaths) {
+  for (const path4 of plan.clearCachePaths) {
     try {
-      rmSync2(path3, { recursive: true, force: true });
-      prompts.log.success(`Cleared stale Pi extension cache: ${path3}`);
+      rmSync2(path4, { recursive: true, force: true });
+      prompts.log.success(`Cleared stale Pi extension cache: ${path4}`);
       fixed += 1;
     } catch (error48) {
-      console.error(`FAIL Could not clear ${path3}: ${error48 instanceof Error ? error48.message : String(error48)}`);
+      console.error(`FAIL Could not clear ${path4}: ${error48 instanceof Error ? error48.message : String(error48)}`);
     }
   }
   return fixed;
@@ -161973,7 +162715,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor3
 });
-import { existsSync as existsSync19, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync21, rmSync as rmSync3 } from "node:fs";
 async function runDoctor3(options) {
   if (options.clear)
     return runClear();
@@ -162057,7 +162799,7 @@ async function runClear() {
     const s = spinner();
     s.start(`Clearing ${item.path}`);
     try {
-      if (existsSync19(item.path)) {
+      if (existsSync21(item.path)) {
         rmSync3(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);
@@ -162090,9 +162832,9 @@ var init_doctor = __esm(async () => {
 });
 
 // src/index.ts
-import { createRequire as createRequire6 } from "node:module";
+import { createRequire as createRequire7 } from "node:module";
 function getVersion() {
-  const req = createRequire6(import.meta.url);
+  const req = createRequire7(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
     try {
       const pkg = req(relPath);
@@ -162122,10 +162864,10 @@ function printUsage() {
   console.log("    (default: auto-detect, prompt if multiple installed)");
   console.log("");
   console.log("  Usage:");
-  console.log("    bunx --bun @cortexkit/magic-context@latest setup");
-  console.log("    bunx --bun @cortexkit/magic-context@latest doctor");
-  console.log("    bunx --bun @cortexkit/magic-context@latest doctor --issue");
-  console.log("    bunx --bun @cortexkit/magic-context@latest doctor migrate \\");
+  console.log("    npx @cortexkit/magic-context@latest setup");
+  console.log("    npx @cortexkit/magic-context@latest doctor");
+  console.log("    npx @cortexkit/magic-context@latest doctor --issue");
+  console.log("    npx @cortexkit/magic-context@latest doctor migrate \\");
   console.log("        --from opencode --to pi --session ses_xxx --dry-run");
   console.log("");
 }