@cortexkit/opencode-magic-context 0.16.2 → 0.16.3

package/dist/index.js

@@ -155708,7 +155708,7 @@ function formatConflictShort(result) {
     "",
     ...result.reasons.map((r) => `• ${r}`),
     "",
-    "Fix: run `bunx --bun @cortexkit/opencode-magic-context@latest doctor`"
+    "Fix: run `npx @cortexkit/opencode-magic-context@latest doctor`"
   ];
   return lines.join(`
 `);
@@ -156108,14 +156108,334 @@ function safeString(value) {
   }
 }
 
+// ../../node_modules/.bun/nanotar@0.3.0/node_modules/nanotar/dist/index.mjs
+function parseTar(data, opts) {
+  const buffer2 = data.buffer || data;
+  const files = [];
+  let offset = 0;
+  let nextExtendedHeader;
+  let globalExtendedHeader;
+  while (offset < buffer2.byteLength - 512) {
+    let name2 = _readString(buffer2, offset, 100);
+    if (name2.length === 0) {
+      break;
+    }
+    if (nextExtendedHeader) {
+      const longName = nextExtendedHeader.path || nextExtendedHeader.linkpath;
+      if (longName) {
+        name2 = longName;
+      }
+    }
+    const mode = _readString(buffer2, offset + 100, 8).trim();
+    const uid = Number.parseInt(_readString(buffer2, offset + 108, 8));
+    const gid = Number.parseInt(_readString(buffer2, offset + 116, 8));
+    const size = _readNumber(buffer2, offset + 124, 12);
+    const seek = 512 + 512 * Math.trunc(size / 512) + (size % 512 ? 512 : 0);
+    const mtime = _readNumber(buffer2, offset + 136, 12);
+    const _type = _readString(buffer2, offset + 156, 1) || "0";
+    const type = tarItemTypeMap[_type] || _type;
+    switch (type) {
+      case "extendedHeader":
+      case "globalExtendedHeader": {
+        const headers = _parseExtendedHeaders(new Uint8Array(buffer2, 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(buffer2, offset + 512, size) };
+        offset += seek;
+        continue;
+      }
+    }
+    const user = _readString(buffer2, offset + 265, 32);
+    const group = _readString(buffer2, offset + 297, 32);
+    name2 = _sanitizePath(name2);
+    const meta3 = {
+      name: name2,
+      type,
+      size,
+      attrs: {
+        ...globalExtendedHeader,
+        ...nextExtendedHeader,
+        mode,
+        uid,
+        gid,
+        mtime,
+        user,
+        group
+      }
+    };
+    nextExtendedHeader = undefined;
+    if (opts?.filter && !opts.filter(meta3)) {
+      offset += seek;
+      continue;
+    }
+    if (opts?.metaOnly) {
+      files.push(meta3);
+      offset += seek;
+      continue;
+    }
+    const data2 = size === 0 ? undefined : new Uint8Array(buffer2, offset + 512, size);
+    files.push({
+      ...meta3,
+      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(path3) {
+  let normalized = path3.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 (path3.endsWith("/") && !result.endsWith("/")) {
+    result += "/";
+  }
+  return result;
+}
+function _readString(buffer2, offset, size) {
+  const view = new Uint8Array(buffer2, offset, size);
+  const i = view.indexOf(0);
+  const td = new TextDecoder;
+  return td.decode(i === -1 ? view : view.slice(0, i));
+}
+function _readNumber(buffer2, offset, size) {
+  const view = new Uint8Array(buffer2, 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_dist2 = __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"
+  };
+});
+
+// src/shared/native-binding.ts
+var exports_native_binding = {};
+__export(exports_native_binding, {
+  resolveBetterSqliteNativeBinding: () => resolveBetterSqliteNativeBinding
+});
+import { existsSync as existsSync7, mkdirSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { createRequire } from "node:module";
+import * as path3 from "node:path";
+function logInfo(message) {
+  log(`${PREFIX} ${message}`);
+}
+function logWarn(message) {
+  log(`${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 url2 = `https://github.com/WiseLibs/better-sqlite3/releases/download/v${pkgVersion}/${filename}`;
+  logInfo(`downloading ${url2}`);
+  const response = await fetch(url2, {
+    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 ${url2}`);
+  }
+  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 promise2 = (async () => {
+    const expected = process.versions.modules;
+    logInfo(`Electron detected (v${process.versions.electron}, NODE_MODULE_VERSION ${expected}); verifying better-sqlite3 binding`);
+    const requireFn = createRequire(import.meta.url);
+    const resolved = resolveBetterSqlite3OnDisk(requireFn);
+    if (!resolved) {
+      return null;
+    }
+    const { binaryPath: diskPath, pkgVersion } = resolved;
+    if (existsSync7(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 (existsSync7(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`);
+    }
+    mkdirSync(path3.dirname(cachedPath), { recursive: true });
+    const nodeFileBytes = await downloadElectronPrebuild(pkgVersion, expected);
+    writeFileSync3(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 = promise2;
+  try {
+    return await promise2;
+  } finally {
+    if (inFlight === promise2) {
+      inFlight = null;
+    }
+  }
+}
+var PREFIX = "[native-binding]", inFlight = null;
+var init_native_binding = __esm(() => {
+  init_dist2();
+  init_data_path();
+  init_logger();
+});
+
 // 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;
 });
 
@@ -156847,9 +157167,9 @@ __export(exports_read_session_db, {
   findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
   closeReadOnlySessionDb: () => closeReadOnlySessionDb
 });
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function getOpenCodeDbPath() {
-  return join10(getDataDir(), "opencode", "opencode.db");
+  return join11(getDataDir(), "opencode", "opencode.db");
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -156951,9 +157271,9 @@ function cosineSimilarity(a, b) {
 }
 
 // src/features/magic-context/memory/embedding-local.ts
-import { mkdirSync } from "node:fs";
+import { mkdirSync as mkdirSync2 } from "node:fs";
 import { open, stat, unlink, writeFile } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function acquireModelLoadLock(lockPath) {
   const waitStart = Date.now();
   while (true) {
@@ -157087,15 +157407,15 @@ class LocalEmbeddingProvider {
         if (LogLevel && "ERROR" in LogLevel) {
           env.logLevel = LogLevel.ERROR;
         }
-        const modelCacheDir = join12(getMagicContextStorageDir(), "models");
+        const modelCacheDir = join13(getMagicContextStorageDir(), "models");
         try {
-          mkdirSync(modelCacheDir, { recursive: true });
+          mkdirSync2(modelCacheDir, { recursive: true });
           env.cacheDir = modelCacheDir;
         } catch {
           log("[magic-context] could not create model cache dir, using library default");
         }
         const createPipeline = transformersModule.pipeline;
-        const lockPath = join12(modelCacheDir, ".load.lock");
+        const lockPath = join13(modelCacheDir, ".load.lock");
         const releaseLock = await acquireModelLoadLock(lockPath);
         const stopHeartbeat = startLockHeartbeat(lockPath);
         try {
@@ -157666,7 +157986,7 @@ var init_storage_memory_fts = __esm(() => {
 // src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import path3 from "node:path";
+import path4 from "node:path";
 function getRootCommitHash(directory) {
   try {
     const hash2 = execSync("git rev-list --max-parents=0 HEAD", {
@@ -157683,12 +158003,12 @@ function getRootCommitHash(directory) {
   }
 }
 function directoryFallback(directory) {
-  const canonical = path3.resolve(directory);
+  const canonical = path4.resolve(directory);
   const hash2 = createHash2("md5").update(canonical).digest("hex").slice(0, 12);
   return `dir:${hash2}`;
 }
 function resolveProjectIdentity(directory) {
-  const resolved = path3.resolve(directory);
+  const resolved = path4.resolve(directory);
   const cached2 = resolvedCache.get(resolved);
   if (cached2 !== undefined) {
     return cached2;
@@ -158467,25 +158787,25 @@ var init_migrations = __esm(async () => {
 });
 
 // src/features/magic-context/storage-db.ts
-import { copyFileSync, cpSync, existsSync as existsSync8, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join13 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync9, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join14 } from "node:path";
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join13(dbDir, "context.db") };
+  return { dbDir, dbPath: join14(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync8(targetDbPath))
+  if (existsSync9(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join13(legacyDir, "context.db");
-  if (!existsSync8(legacyDbPath))
+  const legacyDbPath = join14(legacyDir, "context.db");
+  if (!existsSync9(legacyDbPath))
     return;
   log(`[magic-context] migrating legacy plugin storage: ${legacyDir} -> ${targetDbDir} (legacy left in place as backup)`);
-  mkdirSync2(targetDbDir, { recursive: true });
+  mkdirSync3(targetDbDir, { recursive: true });
   for (const suffix of ["", "-wal", "-shm"]) {
     const src = `${legacyDbPath}${suffix}`;
-    const dst = join13(targetDbDir, `context.db${suffix}`);
-    if (existsSync8(src)) {
+    const dst = join14(targetDbDir, `context.db${suffix}`);
+    if (existsSync9(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error48) {
@@ -158493,9 +158813,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join13(legacyDir, "models");
-  const targetModelsDir = join13(targetDbDir, "models");
-  if (existsSync8(legacyModelsDir) && !existsSync8(targetModelsDir)) {
+  const legacyModelsDir = join14(legacyDir, "models");
+  const targetModelsDir = join14(targetDbDir, "models");
+  if (existsSync9(legacyModelsDir) && !existsSync9(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error48) {
@@ -158875,7 +159195,7 @@ function openDatabase() {
   }
   try {
     migrateLegacyStorageIfNeeded(dbPath, dbDir);
-    mkdirSync2(dbDir, { recursive: true });
+    mkdirSync3(dbDir, { recursive: true });
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
@@ -159645,9 +159965,9 @@ var init_storage = __esm(async () => {
 
 // src/shared/models-dev-cache.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir8, platform as platform3 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function hashFast(input) {
   return createHash3("sha1").update(input).digest("hex");
 }
@@ -159658,16 +159978,16 @@ function getModelsJsonPath() {
   const cacheBase = getCacheDir();
   const source = process.env.OPENCODE_MODELS_URL?.trim();
   const filename = source && source !== "https://models.dev" ? `models-${hashFast(source)}.json` : "models.json";
-  return join14(cacheBase, "opencode", filename);
+  return join15(cacheBase, "opencode", filename);
 }
 function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  const configDir = envDir ? envDir : platform3() === "win32" ? join14(homedir8(), ".config", "opencode") : join14(process.env.XDG_CONFIG_HOME || join14(homedir8(), ".config"), "opencode");
-  const jsonc = join14(configDir, "opencode.jsonc");
-  if (existsSync9(jsonc))
+  const configDir = envDir ? envDir : platform3() === "win32" ? join15(homedir8(), ".config", "opencode") : join15(process.env.XDG_CONFIG_HOME || join15(homedir8(), ".config"), "opencode");
+  const jsonc = join15(configDir, "opencode.jsonc");
+  if (existsSync10(jsonc))
     return jsonc;
-  const json2 = join14(configDir, "opencode.json");
-  if (existsSync9(json2))
+  const json2 = join15(configDir, "opencode.json");
+  if (existsSync10(json2))
     return json2;
   return null;
 }
@@ -159710,7 +160030,7 @@ function loadModelsDevMetadataFromFile() {
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
-    if (existsSync9(modelsJsonPath)) {
+    if (existsSync10(modelsJsonPath)) {
       fileFound = true;
       const raw = readFileSync7(modelsJsonPath, "utf-8");
       const data = JSON.parse(raw);
@@ -159727,7 +160047,7 @@ function loadModelsDevMetadataFromFile() {
   }
   try {
     const configPath = getOpencodeConfigPath();
-    if (configPath && existsSync9(configPath)) {
+    if (configPath && existsSync10(configPath)) {
       let raw = readFileSync7(configPath, "utf-8");
       raw = raw.replace(/"(?:[^"\\]|\\.)*"|\/\/.*$/gm, (match) => match.startsWith('"') ? match : "");
       const config2 = JSON.parse(raw);
@@ -160059,9 +160379,9 @@ var init_compartment_runner_validation = __esm(async () => {
 });
 
 // src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync3, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdirSync as mkdirSync4, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
     ...args,
@@ -160301,11 +160621,11 @@ function cleanupHistorianDump(sessionId, dumpPath) {
 }
 function dumpHistorianResponse(sessionId, label, text) {
   try {
-    mkdirSync3(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
+    mkdirSync4(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join15(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
-    writeFileSync3(dumpPath, text, "utf8");
+    const dumpPath = join16(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    writeFileSync4(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
       dumpPath
@@ -160329,7 +160649,7 @@ var init_compartment_runner_historian = __esm(async () => {
   init_assistant_message_extractor();
   init_compartment_prompt();
   await init_compartment_runner_validation();
-  HISTORIAN_RESPONSE_DUMP_DIR = join15(tmpdir2(), "magic-context-historian");
+  HISTORIAN_RESPONSE_DUMP_DIR = join16(tmpdir2(), "magic-context-historian");
 });
 
 // src/hooks/magic-context/compartment-runner-state-xml.ts
@@ -161308,7 +161628,7 @@ var init_derive_budgets = __esm(() => {
 });
 
 // src/features/magic-context/compaction-marker.ts
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function randomBase62(length) {
   const chars = [];
   for (let i = 0;i < length; i++) {
@@ -161328,7 +161648,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join16(getDataDir(), "opencode", "opencode.db");
+  return join17(getDataDir(), "opencode", "opencode.db");
 }
 function isOpenCodeSchemaCompatible(db, dbPath) {
   if (cachedSchemaCompatible?.path === dbPath) {
@@ -161465,7 +161785,7 @@ var init_compaction_marker = __esm(async () => {
 });
 
 // src/hooks/magic-context/compaction-marker-manager.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function updateCompactionMarkerAfterPublication(db, sessionId, lastCompartmentEnd, directory) {
   const existing = getPersistedCompactionMarkerState(db, sessionId);
   if (existing) {
@@ -161508,7 +161828,7 @@ function removeCompactionMarkerForSession(db, sessionId) {
   }
 }
 function checkCompactionMarkerConsistency(db) {
-  const opencodeDbPath = join17(getDataDir(), "opencode", "opencode.db");
+  const opencodeDbPath = join18(getDataDir(), "opencode", "opencode.db");
   let opencodeDb;
   try {
     opencodeDb = new Database(opencodeDbPath, { readonly: true });
@@ -161895,31 +162215,31 @@ var init_caveman = __esm(() => {
 });
 
 // src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function maybeWriteHistorianStateFile(sessionId, existingState) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
-    mkdirSync4(HISTORIAN_STATE_DIR, { recursive: true });
-    const path4 = join18(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
-    writeFileSync4(path4, existingState, "utf8");
-    return path4;
+    mkdirSync5(HISTORIAN_STATE_DIR, { recursive: true });
+    const path5 = join19(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
+    writeFileSync5(path5, existingState, "utf8");
+    return path5;
   } catch {
     return;
   }
 }
-function cleanupHistorianStateFile(path4) {
-  if (!path4)
+function cleanupHistorianStateFile(path5) {
+  if (!path5)
     return;
   try {
-    unlinkSync2(path4);
+    unlinkSync2(path5);
   } catch {}
 }
 var HISTORIAN_STATE_INLINE_THRESHOLD = 30000, HISTORIAN_STATE_DIR;
 var init_historian_state_file = __esm(() => {
-  HISTORIAN_STATE_DIR = join18(tmpdir3(), "magic-context-historian");
+  HISTORIAN_STATE_DIR = join19(tmpdir3(), "magic-context-historian");
 });
 
 // src/features/magic-context/memory/embedding-backfill.ts
@@ -162989,8 +163309,8 @@ var exports_tui_config = {};
 __export(exports_tui_config, {
   ensureTuiPluginEntry: () => ensureTuiPluginEntry
 });
-import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join21 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname6, join as join22 } from "node:path";
 function isMagicContextEntry(entry) {
   if (!entry)
     return false;
@@ -163004,11 +163324,11 @@ function isMagicContextEntry(entry) {
 }
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join21(configDir, "tui.jsonc");
-  const jsonPath = join21(configDir, "tui.json");
-  if (existsSync11(jsoncPath))
+  const jsoncPath = join22(configDir, "tui.jsonc");
+  const jsonPath = join22(configDir, "tui.json");
+  if (existsSync12(jsoncPath))
     return jsoncPath;
-  if (existsSync11(jsonPath))
+  if (existsSync12(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -163016,7 +163336,7 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
-    if (existsSync11(configPath)) {
+    if (existsSync12(configPath)) {
       const raw = readFileSync9(configPath, "utf-8");
       config2 = import_comment_json3.parse(raw) ?? {};
     }
@@ -163036,8 +163356,8 @@ function ensureTuiPluginEntry() {
       plugins.push(PLUGIN_ENTRY);
     }
     config2.plugin = plugins;
-    mkdirSync6(dirname5(configPath), { recursive: true });
-    writeFileSync6(configPath, `${import_comment_json3.stringify(config2, null, 2)}
+    mkdirSync7(dirname6(configPath), { recursive: true });
+    writeFileSync7(configPath, `${import_comment_json3.stringify(config2, null, 2)}
 `);
     log(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -164130,24 +164450,27 @@ function stripPackageNameFromPath(pathValue, packageName) {
   }
   return current;
 }
-function removeFromBunLock(installDir, packageName) {
-  const lockPath = join5(installDir, "bun.lock");
+function removeFromPackageLock(installDir, packageName) {
+  const lockPath = join5(installDir, "package-lock.json");
   if (!existsSync5(lockPath))
     return false;
   try {
     const lock = import_comment_json2.parse(readFileSync5(lockPath, "utf-8"));
     let modified = false;
-    if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
-      delete lock.workspaces[""].dependencies[packageName];
-      modified = true;
+    if (lock.packages) {
+      const key = `node_modules/${packageName}`;
+      if (lock.packages[key] !== undefined) {
+        delete lock.packages[key];
+        modified = true;
+      }
     }
-    if (lock.packages?.[packageName]) {
-      delete lock.packages[packageName];
+    if (lock.dependencies?.[packageName]) {
+      delete lock.dependencies[packageName];
       modified = true;
     }
     if (modified) {
       writeFileSync2(lockPath, JSON.stringify(lock, null, 2));
-      log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
+      log(`[auto-update-checker] Removed from package-lock.json: ${packageName}`);
     }
     return modified;
   } catch {
@@ -164212,7 +164535,7 @@ function preparePackageUpdate(version2, packageName = PACKAGE_NAME, runtimePacka
     if (!ensureDependencyVersion(installContext.packageJsonPath, packageName, version2))
       return null;
     const packageRemoved = removeInstalledPackage(installContext.installDir, packageName);
-    const lockRemoved = removeFromBunLock(installContext.installDir, packageName);
+    const lockRemoved = removeFromPackageLock(installContext.installDir, packageName);
     if (!packageRemoved && !lockRemoved) {
       log(`[auto-update-checker] No cached package artifacts removed for ${packageName}; continuing with updated dependency spec`);
     }
@@ -164222,12 +164545,12 @@ function preparePackageUpdate(version2, packageName = PACKAGE_NAME, runtimePacka
     return null;
   }
 }
-async function runBunInstallSafe(installDir, options = {}) {
+async function runNpmInstallSafe(installDir, options = {}) {
   let timeout = null;
   try {
     if (options.signal?.aborted)
       return false;
-    const proc = spawn("bun", ["install"], {
+    const proc = spawn("npm", ["install", "--no-audit", "--no-fund", "--no-progress"], {
       cwd: installDir,
       stdio: "pipe"
     });
@@ -164252,7 +164575,7 @@ async function runBunInstallSafe(installDir, options = {}) {
     }
     return result;
   } catch (err) {
-    warn2(`[auto-update-checker] bun install error: ${String(err)}`);
+    warn2(`[auto-update-checker] npm install error: ${String(err)}`);
     return false;
   } finally {
     if (timeout)
@@ -164370,7 +164693,7 @@ async function runBackgroundUpdateCheck(ctx, options) {
     warn3("[auto-update-checker] Failed to prepare install root for auto-update");
     return;
   }
-  const installSuccess = await runBunInstallSafe(installDir, { signal: options.signal });
+  const installSuccess = await runNpmInstallSafe(installDir, { signal: options.signal });
   if (installSuccess) {
     showToast(ctx, "Magic Context Updated!", `v${currentVersion} → v${latestVersion}
 Restart OpenCode to apply.`, "success", 8000);
@@ -164378,7 +164701,7 @@ Restart OpenCode to apply.`, "success", 8000);
     return;
   }
   showToast(ctx, `Magic Context ${latestVersion}`, `v${latestVersion} available, but auto-update failed to install it. Check logs or retry manually.`, "error", 8000);
-  warn3("[auto-update-checker] bun install failed; update not installed");
+  warn3("[auto-update-checker] npm install failed; update not installed");
 }
 function showToast(ctx, title, message, variant = "info", duration3 = 3000) {
   ctx.client.tui.showToast({ body: { title, message, variant, duration: duration3 } }).catch(() => {});
@@ -164395,7 +164718,8 @@ function createLiveSessionState() {
     agentBySession: new Map,
     historyRefreshSessions: new Set,
     systemPromptRefreshSessions: new Set,
-    pendingMaterializationSessions: new Set
+    pendingMaterializationSessions: new Set,
+    sessionDirectoryBySession: new Map
   };
 }
 
@@ -164562,8 +164886,8 @@ init_assistant_message_extractor();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { existsSync as existsSync7 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // src/features/magic-context/key-files/identify-key-files.ts
 init_logger();
@@ -164954,11 +165278,11 @@ function countNewIds(beforeIds, afterIds) {
   return count;
 }
 function getOpenCodeDbPath2() {
-  return join11(getDataDir(), "opencode", "opencode.db");
+  return join12(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync7(dbPath)) {
+  if (!existsSync8(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -165208,8 +165532,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync7(join11(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync7(join11(docsDir, "STRUCTURE.md"))
+          architecture: existsSync8(join12(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync8(join12(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -170508,12 +170832,16 @@ function createTransform(deps) {
     const reducedMode = sessionMeta.isSubagent;
     const fullFeatureMode = !reducedMode;
     let sessionDirectory = deps.directory ?? "";
-    if (deps.client !== undefined) {
+    const cachedDirectory = deps.sessionDirectoryBySession?.get(sessionId);
+    if (cachedDirectory && cachedDirectory.length > 0) {
+      sessionDirectory = cachedDirectory;
+    } else if (deps.client !== undefined) {
       try {
         const sessionResponse = await deps.client.session.get({ path: { id: sessionId } }).catch(() => null);
         const sessionInfo = sessionResponse?.data;
         if (sessionInfo && typeof sessionInfo.directory === "string" && sessionInfo.directory.length > 0) {
           sessionDirectory = sessionInfo.directory;
+          deps.sessionDirectoryBySession?.set(sessionId, sessionDirectory);
         }
       } catch {}
     }
@@ -171570,6 +171898,7 @@ function createEventHook(args) {
       args.liveModelBySession.delete(sessionId);
       args.variantBySession.delete(sessionId);
       args.agentBySession.delete(sessionId);
+      args.sessionDirectoryBySession.delete(sessionId);
       args.recentReduceBySession.delete(sessionId);
       args.toolUsageSinceUserTurn.delete(sessionId);
       args.historyRefreshSessions.delete(sessionId);
@@ -171627,8 +171956,8 @@ init_send_session_notification();
 
 // src/hooks/magic-context/system-prompt-hash.ts
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync8, realpathSync } from "node:fs";
-import { join as join19, resolve as resolve4, sep } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync8, realpathSync } from "node:fs";
+import { join as join20, resolve as resolve4, sep } from "node:path";
 
 // src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -171741,9 +172070,9 @@ var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join19(directory, filename);
+    const filePath = join20(directory, filename);
     try {
-      if (existsSync10(filePath)) {
+      if (existsSync11(filePath)) {
         const content = readFileSync8(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
@@ -171856,7 +172185,7 @@ ${items}
                 log(`[magic-context] key file path escapes project root, skipping: ${entry.filePath}`);
                 continue;
               }
-              if (!existsSync10(absPath))
+              if (!existsSync11(absPath))
                 continue;
               let realPath;
               try {
@@ -172024,6 +172353,7 @@ function createMagicContextHook(deps) {
   const variantBySession = deps.liveSessionState?.variantBySession ?? new Map;
   const liveModelBySession = deps.liveSessionState?.liveModelBySession ?? new Map;
   const agentBySession = deps.liveSessionState?.agentBySession ?? new Map;
+  const sessionDirectoryBySession = deps.liveSessionState?.sessionDirectoryBySession ?? new Map;
   const recentReduceBySession = new Map;
   const toolUsageSinceUserTurn = new Map;
   const resolveLiveModel = (sessionId) => {
@@ -172091,6 +172421,7 @@ function createMagicContextHook(deps) {
     compressorMaxMergeDepth: deps.config.compressor?.enabled === false ? undefined : deps.config.compressor?.max_merge_depth,
     compressorCooldownMs: deps.config.compressor?.enabled === false ? undefined : deps.config.compressor?.cooldown_ms,
     liveModelBySession,
+    sessionDirectoryBySession,
     autoSearch: deps.config.experimental?.auto_search?.enabled ? {
       enabled: true,
       scoreThreshold: deps.config.experimental.auto_search.score_threshold,
@@ -172255,6 +172586,7 @@ function createMagicContextHook(deps) {
     liveModelBySession,
     variantBySession,
     agentBySession,
+    sessionDirectoryBySession,
     recentReduceBySession,
     toolUsageSinceUserTurn,
     historyRefreshSessions,
@@ -173898,19 +174230,19 @@ init_models_dev_cache();
 
 // src/shared/rpc-server.ts
 init_logger();
-import { mkdirSync as mkdirSync5, renameSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdirSync as mkdirSync6, renameSync, unlinkSync as unlinkSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname4 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { createHash as createHash5 } from "node:crypto";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function projectHash(directory) {
   const normalized = directory.replace(/\/+$/, "");
   return createHash5("sha256").update(normalized).digest("hex").slice(0, 16);
 }
 function rpcPortFilePath(storageDir, directory) {
-  return join20(storageDir, "rpc", projectHash(directory), "port");
+  return join21(storageDir, "rpc", projectHash(directory), "port");
 }
 
 // src/shared/rpc-server.ts
@@ -173941,10 +174273,10 @@ class MagicContextRpcServer {
         this.port = addr.port;
         this.server = server;
         try {
-          const dir = dirname4(this.portFilePath);
-          mkdirSync5(dir, { recursive: true });
+          const dir = dirname5(this.portFilePath);
+          mkdirSync6(dir, { recursive: true });
           const tmpPath = `${this.portFilePath}.tmp`;
-          writeFileSync5(tmpPath, String(this.port), "utf-8");
+          writeFileSync6(tmpPath, String(this.port), "utf-8");
           renameSync(tmpPath, this.portFilePath);
           log(`[rpc] server listening on 127.0.0.1:${this.port}`);
         } catch (err) {