@cortexkit/pi-magic-context 0.16.1 → 0.16.3

package/dist/subagent-entry.js

@@ -14064,6 +14064,13 @@ var init_magic_context = __esm(() => {
       min_clusters: exports_external.number().min(1).default(3)
     }).default({ enabled: true, min_clusters: 3 }),
     compaction_markers: exports_external.boolean().default(true),
+    system_prompt_injection: exports_external.object({
+      enabled: exports_external.boolean().default(true),
+      skip_signatures: exports_external.array(exports_external.string()).default(["<!-- magic-context: skip -->"])
+    }).default({
+      enabled: true,
+      skip_signatures: ["<!-- magic-context: skip -->"]
+    }),
     compressor: exports_external.object({
       enabled: exports_external.boolean().default(true),
       min_compartment_ratio: exports_external.number().min(100).max(1e4).default(DEFAULT_COMPRESSOR_MIN_COMPARTMENT_RATIO),
@@ -15036,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(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_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 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 (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(path3.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;
 });
 
@@ -22663,10 +22990,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join5 = (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 join6 = (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 join5(comment, inside, gap);
+    return join6(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -22688,13 +23015,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join5(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join6(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 += join5(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join6(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) => {
@@ -22715,13 +23042,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join5(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join6(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 += join5(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join6(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) {
@@ -22822,9 +23149,9 @@ __export(exports_read_session_db, {
   findLastAssistantModelFromOpenCodeDb: () => findLastAssistantModelFromOpenCodeDb,
   closeReadOnlySessionDb: () => closeReadOnlySessionDb
 });
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function getOpenCodeDbPath() {
-  return join6(getDataDir(), "opencode", "opencode.db");
+  return join7(getDataDir(), "opencode", "opencode.db");
 }
 function closeCachedReadOnlyDb() {
   if (!cachedReadOnlyDb) {
@@ -22913,8 +23240,8 @@ init_embedding();
 
 // ../plugin/src/features/magic-context/storage-db.ts
 init_data_path();
-import { copyFileSync, cpSync, existsSync, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join4 } from "node:path";
+import { copyFileSync, cpSync, existsSync as existsSync2, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join5 } from "node:path";
 
 // ../plugin/src/shared/error-message.ts
 function getErrorMessage(error48) {
@@ -23243,21 +23570,21 @@ var persistenceByDatabase = new WeakMap;
 var persistenceErrorByDatabase = new WeakMap;
 function resolveDatabasePath() {
   const dbDir = getMagicContextStorageDir();
-  return { dbDir, dbPath: join4(dbDir, "context.db") };
+  return { dbDir, dbPath: join5(dbDir, "context.db") };
 }
 function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
-  if (existsSync(targetDbPath))
+  if (existsSync2(targetDbPath))
     return;
   const legacyDir = getLegacyOpenCodeMagicContextStorageDir();
-  const legacyDbPath = join4(legacyDir, "context.db");
-  if (!existsSync(legacyDbPath))
+  const legacyDbPath = join5(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 = join4(targetDbDir, `context.db${suffix}`);
-    if (existsSync(src)) {
+    const dst = join5(targetDbDir, `context.db${suffix}`);
+    if (existsSync2(src)) {
       try {
         copyFileSync(src, dst);
       } catch (error48) {
@@ -23265,9 +23592,9 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
       }
     }
   }
-  const legacyModelsDir = join4(legacyDir, "models");
-  const targetModelsDir = join4(targetDbDir, "models");
-  if (existsSync(legacyModelsDir) && !existsSync(targetModelsDir)) {
+  const legacyModelsDir = join5(legacyDir, "models");
+  const targetModelsDir = join5(targetDbDir, "models");
+  if (existsSync2(legacyModelsDir) && !existsSync2(targetModelsDir)) {
     try {
       cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
     } catch (error48) {
@@ -23647,7 +23974,7 @@ function openDatabase() {
   }
   try {
     migrateLegacyStorageIfNeeded(dbPath, dbDir);
-    mkdirSync2(dbDir, { recursive: true });
+    mkdirSync3(dbDir, { recursive: true });
     const db = new Database(dbPath);
     initializeDatabase(db);
     runMigrations(db);
@@ -23681,14 +24008,14 @@ init_logger();
 
 // src/config/index.ts
 init_magic_context();
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // ../plugin/src/config/variable.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { existsSync as existsSync3, readFileSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { dirname, isAbsolute, resolve } from "node:path";
+import { dirname as dirname2, isAbsolute, resolve } from "node:path";
 var ENV_PATTERN = /\{env:([^}]+)\}/g;
 var FILE_PATTERN = /\{file:([^}]+)\}/g;
 function substituteConfigVariables(input) {
@@ -23707,7 +24034,7 @@ function substituteConfigVariables(input) {
   if (fileMatches.length === 0) {
     return { text, warnings };
   }
-  const configDir = input.configPath ? dirname(input.configPath) : process.cwd();
+  const configDir = input.configPath ? dirname2(input.configPath) : process.cwd();
   let output = "";
   let cursor = 0;
   for (const match of fileMatches) {
@@ -23729,7 +24056,7 @@ function substituteConfigVariables(input) {
     } else if (!isAbsolute(filePath)) {
       filePath = resolve(configDir, filePath);
     }
-    if (!existsSync2(filePath)) {
+    if (!existsSync3(filePath)) {
       warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
       continue;
     }
@@ -23751,38 +24078,38 @@ function substituteConfigVariables(input) {
 var import_comment_json = __toESM(require_src2(), 1);
 var CONFIG_FILE_NAME = "magic-context";
 function getProjectConfigPaths(cwd) {
-  const basePath = join5(cwd, ".pi", CONFIG_FILE_NAME);
+  const basePath = join6(cwd, ".pi", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function getUserConfigPaths() {
   const home = process.env.HOME ?? homedir3();
-  const basePath = join5(home, ".pi", "agent", CONFIG_FILE_NAME);
+  const basePath = join6(home, ".pi", "agent", CONFIG_FILE_NAME);
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path3) => existsSync3(path3));
+  return paths.find((path4) => existsSync4(path4));
 }
-function loadConfigFile(path3, scope) {
+function loadConfigFile(path4, scope) {
   try {
-    const rawText = readFileSync2(path3, "utf-8");
+    const rawText = readFileSync2(path4, "utf-8");
     const substituted = substituteConfigVariables({
       text: rawText,
-      configPath: path3
+      configPath: path4
     });
     return {
-      path: path3,
+      path: path4,
       scope,
       config: import_comment_json.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.`
       ]
     };
   }
@@ -161449,7 +161776,7 @@ init_normalize_hash();
 // ../plugin/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";
 var GIT_TIMEOUT_MS = 5000;
 var resolvedCache = new Map;
 function getRootCommitHash(directory) {
@@ -161468,12 +161795,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;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cortexkit/pi-magic-context",
-	"version": "0.16.1",
+	"version": "0.16.3",
 	"type": "module",
 	"description": "Pi coding agent extension for Magic Context — cross-session memory and context management",
 	"main": "dist/index.js",