@cortexkit/pi-magic-context 0.16.2 → 0.16.3

package/dist/index.js

@@ -15043,14 +15043,334 @@ var init_embedding = __esm(() => {
   SWEEP_MAX_WALL_CLOCK_MS = 10 * 60 * 1000;
 });
 
+// ../../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 name = _readString(buffer2, offset, 100);
+    if (name.length === 0) {
+      break;
+    }
+    if (nextExtendedHeader) {
+      const longName = nextExtendedHeader.path || nextExtendedHeader.linkpath;
+      if (longName) {
+        name = 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);
+    name = _sanitizePath(name);
+    const meta3 = {
+      name,
+      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(path4) {
+  let normalized = path4.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 (path4.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_dist = __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/native-binding.ts
+var exports_native_binding = {};
+__export(exports_native_binding, {
+  resolveBetterSqliteNativeBinding: () => resolveBetterSqliteNativeBinding
+});
+import { existsSync, mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import * as path4 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 = path4.dirname(pkgJsonPath);
+    const pkgJson = requireFn(pkgJsonPath);
+    const binaryPath = path4.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 path4.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 (existsSync(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 (existsSync(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`);
+    }
+    mkdirSync2(path4.dirname(cachedPath), { recursive: true });
+    const nodeFileBytes = await downloadElectronPrebuild(pkgVersion, expected);
+    writeFileSync(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_dist();
+  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;
 });
 
@@ -15072,9 +15392,9 @@ __export(exports_read_session_db, {
   findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
   closeReadOnlySessionDb: () => closeReadOnlySessionDb
 });
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 function getOpenCodeDbPath() {
-  return join4(getDataDir(), "opencode", "opencode.db");
+  return join5(getDataDir(), "opencode", "opencode.db");
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -22792,10 +23112,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join11 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join12 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join11(comment, inside, gap);
+    return join12(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -22817,13 +23137,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join11(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join12(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join11(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join12(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -22844,13 +23164,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join11(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join12(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join11(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join12(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -22944,8 +23264,8 @@ var require_src2 = __commonJS((exports, module) => {
 
 // src/index.ts
 init_embedding();
-import { createRequire } from "node:module";
-import { join as join13 } from "node:path";
+import { createRequire as createRequire2 } from "node:module";
+import { join as join14 } from "node:path";
 
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execSync } from "node:child_process";
@@ -156428,8 +156748,8 @@ function ensureMessagesIndexed(db, sessionId, readMessages) {
 }
 // ../plugin/src/features/magic-context/storage-db.ts
 init_data_path();
-import { copyFileSync, cpSync, existsSync, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync2, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join6 } from "node:path";
 
 // ../plugin/src/shared/error-message.ts
 function getErrorMessage(error48) {
@@ -156758,21 +157078,21 @@ var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join5(dbDir, "context.db") };
+  return { dbDir, dbPath: join6(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync(targetDbPath))
+  if (existsSync2(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join5(legacyDir, "context.db");
-  if (!existsSync(legacyDbPath))
+  const legacyDbPath = join6(legacyDir, "context.db");
+  if (!existsSync2(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 = join5(targetDbDir, `context.db${suffix}`);
-    if (existsSync(src)) {
+    const dst = join6(targetDbDir, `context.db${suffix}`);
+    if (existsSync2(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error48) {
@@ -156780,9 +157100,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join5(legacyDir, "models");
-  const targetModelsDir = join5(targetDbDir, "models");
-  if (existsSync(legacyModelsDir) && !existsSync(targetModelsDir)) {
+  const legacyModelsDir = join6(legacyDir, "models");
+  const targetModelsDir = join6(targetDbDir, "models");
+  if (existsSync2(legacyModelsDir) && !existsSync2(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error48) {
@@ -157162,7 +157482,7 @@ function openDatabase() {
   }
   try {
     migrateLegacyStorageIfNeeded(dbPath, dbDir);
-    mkdirSync2(dbDir, { recursive: true });
+    mkdirSync3(dbDir, { recursive: true });
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
@@ -157958,9 +158278,9 @@ function expandFallbackChain(chain) {
 init_data_path();
 init_logger();
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { existsSync as existsSync3, readFileSync } from "node:fs";
 import { homedir as homedir2, platform } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var RELOAD_INTERVAL_MS = 5 * 60 * 1000;
 var apiCache = null;
 var fileCache = null;
@@ -157975,16 +158295,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 join6(cacheBase, "opencode", filename);
+  return join7(cacheBase, "opencode", filename);
 }
 function getOpencodeConfigPath() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  const configDir = envDir ? envDir : platform() === "win32" ? join6(homedir2(), ".config", "opencode") : join6(process.env.XDG_CONFIG_HOME || join6(homedir2(), ".config"), "opencode");
-  const jsonc = join6(configDir, "opencode.jsonc");
-  if (existsSync2(jsonc))
+  const configDir = envDir ? envDir : platform() === "win32" ? join7(homedir2(), ".config", "opencode") : join7(process.env.XDG_CONFIG_HOME || join7(homedir2(), ".config"), "opencode");
+  const jsonc = join7(configDir, "opencode.jsonc");
+  if (existsSync3(jsonc))
     return jsonc;
-  const json2 = join6(configDir, "opencode.json");
-  if (existsSync2(json2))
+  const json2 = join7(configDir, "opencode.json");
+  if (existsSync3(json2))
     return json2;
   return null;
 }
@@ -158027,7 +158347,7 @@ function loadModelsDevMetadataFromFile() {
   const modelsJsonPath = getModelsJsonPath();
   let fileFound = false;
   try {
-    if (existsSync2(modelsJsonPath)) {
+    if (existsSync3(modelsJsonPath)) {
       fileFound = true;
       const raw = readFileSync(modelsJsonPath, "utf-8");
       const data = JSON.parse(raw);
@@ -158044,7 +158364,7 @@ function loadModelsDevMetadataFromFile() {
   }
   try {
     const configPath = getOpencodeConfigPath();
-    if (configPath && existsSync2(configPath)) {
+    if (configPath && existsSync3(configPath)) {
       let raw = readFileSync(configPath, "utf-8");
       raw = raw.replace(/"(?:[^"\\]|\\.)*"|\/\/.*$/gm, (match) => match.startsWith('"') ? match : "");
       const config2 = JSON.parse(raw);
@@ -158387,15 +158707,15 @@ init_logger();
 
 // src/subagent-runner.ts
 import * as childProcess from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
-import { dirname, resolve as resolvePath } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { dirname as dirname2, resolve as resolvePath } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 function resolveSubagentEntryPath() {
   try {
-    const here = dirname(fileURLToPath(import.meta.url));
+    const here = dirname2(fileURLToPath(import.meta.url));
     const candidate = resolvePath(here, "subagent-entry.js");
-    if (existsSync3(candidate))
+    if (existsSync4(candidate))
       return candidate;
     return;
   } catch {
@@ -158994,8 +159314,8 @@ function releaseLease(db, holderId) {
   })();
 }
 // ../plugin/src/features/magic-context/dreamer/runner.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // ../plugin/src/shared/index.ts
 init_logger();
@@ -160393,11 +160713,11 @@ function countNewIds(beforeIds, afterIds) {
   return count;
 }
 function getOpenCodeDbPath2() {
-  return join7(getDataDir(), "opencode", "opencode.db");
+  return join8(getDataDir(), "opencode", "opencode.db");
 }
 function openOpenCodeDb() {
   const dbPath = getOpenCodeDbPath2();
-  if (!existsSync4(dbPath)) {
+  if (!existsSync5(dbPath)) {
     log(`[key-files] OpenCode DB not found at ${dbPath} — skipping`);
     return null;
   }
@@ -160647,8 +160967,8 @@ async function runDream(args) {
       try {
         const docsDir = args.sessionDirectory ?? args.projectIdentity;
         const existingDocs = taskName === "maintain-docs" ? {
-          architecture: existsSync4(join7(docsDir, "ARCHITECTURE.md")),
-          structure: existsSync4(join7(docsDir, "STRUCTURE.md"))
+          architecture: existsSync5(join8(docsDir, "ARCHITECTURE.md")),
+          structure: existsSync5(join8(docsDir, "STRUCTURE.md"))
         } : undefined;
         const userMemories = taskName === "archive-stale" ? getActiveUserMemories(args.db).map((um) => ({
           id: um.id,
@@ -165812,28 +166132,28 @@ function getReducedRecompTokenBudget(currentBudget) {
 }
 
 // ../plugin/src/hooks/magic-context/historian-state-file.ts
-import { mkdirSync as mkdirSync3, unlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync as mkdirSync4, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var HISTORIAN_STATE_INLINE_THRESHOLD = 30000;
-var HISTORIAN_STATE_DIR = join8(tmpdir2(), "magic-context-historian");
+var HISTORIAN_STATE_DIR = join9(tmpdir2(), "magic-context-historian");
 function maybeWriteHistorianStateFile(sessionId, existingState) {
   if (existingState.length <= HISTORIAN_STATE_INLINE_THRESHOLD)
     return;
   try {
-    mkdirSync3(HISTORIAN_STATE_DIR, { recursive: true });
-    const path4 = join8(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
-    writeFileSync(path4, existingState, "utf8");
-    return path4;
+    mkdirSync4(HISTORIAN_STATE_DIR, { recursive: true });
+    const path5 = join9(HISTORIAN_STATE_DIR, `state-${sessionId}-${Date.now()}.xml`);
+    writeFileSync2(path5, existingState, "utf8");
+    return path5;
   } catch {
     return;
   }
 }
-function cleanupHistorianStateFile(path4) {
-  if (!path4)
+function cleanupHistorianStateFile(path5) {
+  if (!path5)
     return;
   try {
-    unlinkSync(path4);
+    unlinkSync(path5);
   } catch {}
 }
 
@@ -168038,7 +168358,7 @@ init_logger();
 init_data_path();
 init_logger();
 await init_sqlite();
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 var BASE62_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 function randomBase62(length) {
   const chars = [];
@@ -168059,7 +168379,7 @@ function generatePartId(timestampMs, counter = 0n) {
   return generateId("prt", timestampMs, counter);
 }
 function getOpenCodeDbPath3() {
-  return join9(getDataDir(), "opencode", "opencode.db");
+  return join10(getDataDir(), "opencode", "opencode.db");
 }
 var cachedWriteDb = null;
 var REQUIRED_MESSAGE_COLUMNS = ["id", "session_id", "time_created", "time_updated", "data"];
@@ -168612,11 +168932,11 @@ async function runCompressorPass2(args) {
 }
 
 // ../plugin/src/hooks/magic-context/compartment-runner-historian.ts
-import { mkdirSync as mkdirSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { mkdirSync as mkdirSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 init_magic_context();
-var HISTORIAN_RESPONSE_DUMP_DIR = join10(tmpdir3(), "magic-context-historian");
+var HISTORIAN_RESPONSE_DUMP_DIR = join11(tmpdir3(), "magic-context-historian");
 var MAX_HISTORIAN_RETRIES = 2;
 async function runValidatedHistorianPass(args) {
   const firstRun = await runHistorianPrompt({
@@ -168857,11 +169177,11 @@ function cleanupHistorianDump(sessionId, dumpPath) {
 }
 function dumpHistorianResponse(sessionId, label, text) {
   try {
-    mkdirSync4(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
+    mkdirSync5(HISTORIAN_RESPONSE_DUMP_DIR, { recursive: true });
     const safeSessionId = sanitizeDumpName(sessionId);
     const safeLabel = sanitizeDumpName(label);
-    const dumpPath = join10(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
-    writeFileSync2(dumpPath, text, "utf8");
+    const dumpPath = join11(HISTORIAN_RESPONSE_DUMP_DIR, `${safeSessionId}-${safeLabel}-${Date.now()}.xml`);
+    writeFileSync3(dumpPath, text, "utf8");
     sessionLog(sessionId, "compartment agent: historian response dumped", {
       label,
       dumpPath
@@ -169872,8 +170192,8 @@ function createPiRecompClient(args) {
 function readPathId(input) {
   if (typeof input !== "object" || input === null)
     return "";
-  const path4 = input.path;
-  return typeof path4?.id === "string" ? path4.id : "";
+  const path5 = input.path;
+  return typeof path5?.id === "string" ? path5.id : "";
 }
 function readBody(input) {
   if (typeof input !== "object" || input === null)
@@ -170028,7 +170348,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/pi-magic-context",
-  version: "0.16.2",
+  version: "0.16.3",
   type: "module",
   description: "Pi coding agent extension for Magic Context — cross-session memory and context management",
   main: "dist/index.js",
@@ -170565,14 +170885,14 @@ function readHistorianState(db, sessionId, meta3) {
 
 // src/config/index.ts
 init_magic_context();
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname2, isAbsolute, resolve } from "node:path";
+import { dirname as dirname3, isAbsolute, resolve } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function substituteConfigVariables(input) {
@@ -170591,7 +170911,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text, warnings };
   }
-  const configDir = input.configPath ? dirname2(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname3(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -170613,7 +170933,7 @@ function substituteConfigVariables(input) {
     } else if (!isAbsolute(filePath)) {
       filePath = resolve(configDir, filePath);
     }
-    if (!existsSync5(filePath)) {
+    if (!existsSync6(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
@@ -170635,38 +170955,38 @@ function substituteConfigVariables(input) {
 var import_comment_json = __toESM(require_src2(), 1);
 var CONFIG_FILE_NAME = "magic-context";
 function getProjectConfigPaths(cwd) {
-  const basePath = join11(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join12(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
   const home = process.env.HOME ?? homedir4();
-  const basePath = join11(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const basePath = join12(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path4) => existsSync6(path4));
+  return paths.find((path5) => existsSync7(path5));
 }
-function loadConfigFile(path4, scope) {
+function loadConfigFile(path5, scope) {
   try {
-    const rawText = readFileSync3(path4, "utf-8");
+    const rawText = readFileSync3(path5, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path4
+      configPath: path5
     });
     return {
-      path: path4,
+      path: path5,
       scope,
       config: import_comment_json.parse(substituted.text),
-      warnings: substituted.warnings.map((warning) => `${path4}: ${warning}`)
+      warnings: substituted.warnings.map((warning) => `${path5}: ${warning}`)
     };
   } catch (error48) {
     const message = error48 instanceof Error ? error48.message : String(error48);
     return {
-      path: path4,
+      path: path5,
       scope,
       config: {},
       warnings: [
-        `${path4}: failed to load config: ${message}; using defaults for this file.`
+        `${path5}: failed to load config: ${message}; using defaults for this file.`
       ]
     };
   }
@@ -170796,8 +171116,8 @@ function stripTagPrefixFromAssistantMessage(message) {
 
 // src/system-prompt.ts
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync4, realpathSync } from "node:fs";
-import { join as join12, resolve as resolve2, sep } from "node:path";
+import { existsSync as existsSync8, readFileSync as readFileSync4, realpathSync } from "node:fs";
+import { join as join13, resolve as resolve2, sep } from "node:path";
 
 // ../plugin/src/agents/magic-context-prompt.ts
 function getToolHistoryGuidance(dropToolStructure) {
@@ -170899,9 +171219,9 @@ var DOC_FILES = ["ARCHITECTURE.md", "STRUCTURE.md"];
 function readProjectDocs(directory) {
   const sections = [];
   for (const filename of DOC_FILES) {
-    const filePath = join12(directory, filename);
+    const filePath = join13(directory, filename);
     try {
-      if (existsSync7(filePath)) {
+      if (existsSync8(filePath)) {
         const content = readFileSync4(filePath, "utf-8").trim();
         if (content.length > 0) {
           sections.push(`<${filename}>
@@ -170945,7 +171265,7 @@ function buildKeyFilesBlock(db, sessionId, directory, tokenBudget) {
         log(`[magic-context-pi] key file path escapes project root, skipping: ${entry.filePath}`);
         continue;
       }
-      if (!existsSync7(absPath))
+      if (!existsSync8(absPath))
         continue;
       let realPath;
       try {
@@ -176022,7 +176342,7 @@ function registerMagicContextTools(pi, opts) {
 }
 
 // src/index.ts
-var PREFIX = "[magic-context][pi]";
+var PREFIX2 = "[magic-context][pi]";
 function persistPiMessageEndModelMeta(args) {
   if (!args.message || typeof args.message !== "object")
     return;
@@ -176039,14 +176359,14 @@ function persistPiMessageEndModelMeta(args) {
   }
 }
 function info(message, data) {
-  log(`${PREFIX} ${message}`, data);
+  log(`${PREFIX2} ${message}`, data);
 }
 function warn(message, data) {
-  log(`${PREFIX} WARN ${message}`, data);
+  log(`${PREFIX2} WARN ${message}`, data);
 }
 var PLUGIN_VERSION = (() => {
   try {
-    const req = createRequire(import.meta.url);
+    const req = createRequire2(import.meta.url);
     return req("../package.json").version;
   } catch {
     return "0.0.0";
@@ -176127,7 +176447,7 @@ function resolveDreamerFromConfig(config2) {
 }
 async function src_default2(pi) {
   const storageDir = getMagicContextStorageDir();
-  const dbPath = join13(storageDir, "context.db");
+  const dbPath = join14(storageDir, "context.db");
   let db;
   try {
     db = openDatabase();