@cortexkit/aft-pi 0.26.4 → 0.27.1

package/dist/index.js

@@ -8301,11 +8301,11 @@ var require_fixed_queue = __commonJS((exports, module) => {
       this.head.push(data);
     }
     shift() {
-      const tail = this.tail;
-      const next = tail.shift();
-      if (tail.isEmpty() && tail.next !== null) {
-        this.tail = tail.next;
-        tail.next = null;
+      const tail2 = this.tail;
+      const next = tail2.shift();
+      if (tail2.isEmpty() && tail2.next !== null) {
+        this.tail = tail2.next;
+        tail2.next = null;
       }
       return next;
     }
@@ -12716,7 +12716,7 @@ var require_snapshot_utils = __commonJS((exports, module) => {
 // ../../node_modules/.bun/undici@8.2.0/node_modules/undici/lib/mock/snapshot-recorder.js
 var require_snapshot_recorder = __commonJS((exports, module) => {
   var { writeFile, readFile, mkdir } = __require("node:fs/promises");
-  var { dirname: dirname2, resolve: resolve2 } = __require("node:path");
+  var { dirname: dirname3, resolve: resolve2 } = __require("node:path");
   var { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = __require("node:timers");
   var { InvalidArgumentError, UndiciError } = require_errors();
   var { hashId, isUrlExcludedFactory, normalizeHeaders, createHeaderFilters } = require_snapshot_utils();
@@ -12911,7 +12911,7 @@ var require_snapshot_recorder = __commonJS((exports, module) => {
         throw new InvalidArgumentError("Snapshot path is required");
       }
       const resolvedPath = resolve2(path);
-      await mkdir(dirname2(resolvedPath), { recursive: true });
+      await mkdir(dirname3(resolvedPath), { recursive: true });
       const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
         hash,
         snapshot
@@ -20784,7 +20784,7 @@ var require_permessage_deflate = __commonJS((exports, module) => {
   var { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __require("node:zlib");
   var { isValidClientWindowBits } = require_util5();
   var { MessageSizeExceededError } = require_errors();
-  var tail = Buffer.from([0, 0, 255, 255]);
+  var tail2 = Buffer.from([0, 0, 255, 255]);
   var kBuffer = Symbol("kBuffer");
   var kLength = Symbol("kLength");
 
@@ -20832,7 +20832,7 @@ var require_permessage_deflate = __commonJS((exports, module) => {
       }
       this.#inflate.write(chunk);
       if (fin) {
-        this.#inflate.write(tail);
+        this.#inflate.write(tail2);
       }
       this.#inflate.flush(() => {
         if (!this.#inflate) {
@@ -24197,10 +24197,10 @@ var require_esprima = __commonJS((exports, module) => {
         }();
         exports2.TaggedTemplateExpression = TaggedTemplateExpression;
         var TemplateElement = function() {
-          function TemplateElement2(value, tail) {
+          function TemplateElement2(value, tail2) {
             this.type = syntax_1.Syntax.TemplateElement;
             this.value = value;
-            this.tail = tail;
+            this.tail = tail2;
           }
           return TemplateElement2;
         }();
@@ -28040,14 +28040,14 @@ var require_esprima = __commonJS((exports, module) => {
             var terminated = false;
             var start = this.index;
             var head = this.source[start] === "`";
-            var tail = false;
+            var tail2 = false;
             var rawOffset = 2;
             ++this.index;
             while (!this.eof()) {
               var ch = this.source[this.index++];
               if (ch === "`") {
                 rawOffset = 1;
-                tail = true;
+                tail2 = true;
                 terminated = true;
                 break;
               } else if (ch === "$") {
@@ -28148,7 +28148,7 @@ var require_esprima = __commonJS((exports, module) => {
               value: this.source.slice(start + 1, this.index - rawOffset),
               cooked,
               head,
-              tail,
+              tail: tail2,
               lineNumber: this.lineNumber,
               lineStart: this.lineStart,
               start,
@@ -30318,10 +30318,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join7 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
+  var join8 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join7(comment, inside, gap);
+    return join8(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -30343,13 +30343,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join7(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join8(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 += join7(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join8(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) => {
@@ -30370,13 +30370,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join7(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join8(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 += join7(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join8(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) {
@@ -30475,8 +30475,6 @@ var require_src2 = __commonJS((exports, module) => {
 
 // src/index.ts
 import { createRequire as createRequire3 } from "node:module";
-import { homedir as homedir9 } from "node:os";
-import { join as join13 } from "node:path";
 
 // ../aft-bridge/dist/active-logger.js
 var ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
@@ -31501,11 +31499,295 @@ async function fetchLatestTag() {
     clearTimeout(timeout);
   }
 }
+// ../aft-bridge/dist/format.js
+function compressionSavingsPercent(original, compressed) {
+  if (original <= 0)
+    return null;
+  const saved = Math.max(0, original - compressed);
+  return Math.round(saved / original * 100);
+}
+// ../aft-bridge/dist/migration.js
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { homedir as homedir4, tmpdir } from "node:os";
+import { dirname, join as join4 } from "node:path";
+
+// ../aft-bridge/dist/resolver.js
+import { execSync, spawnSync } from "node:child_process";
+import { chmodSync as chmodSync2, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync as renameSync2 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+function readBinaryVersion(binaryPath) {
+  try {
+    const result = spawnSync(binaryPath, ["--version"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5000
+    });
+    const stdoutVersion = result.stdout?.trim();
+    const stderrVersion = result.stderr?.trim();
+    const rawVersion = stdoutVersion || stderrVersion;
+    if (!rawVersion)
+      return null;
+    return rawVersion.replace(/^aft\s+/, "");
+  } catch {
+    return null;
+  }
+}
+function copyToVersionedCache(npmBinaryPath, knownVersion) {
+  try {
+    const version = knownVersion ?? readBinaryVersion(npmBinaryPath);
+    if (!version)
+      return null;
+    const tag = version.startsWith("v") ? version : `v${version}`;
+    const cacheDir = getCacheDir();
+    const versionedDir = join3(cacheDir, tag);
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const cachedPath = join3(versionedDir, `aft${ext}`);
+    if (existsSync2(cachedPath)) {
+      const cachedVersion = readBinaryVersion(cachedPath);
+      if (cachedVersion === version)
+        return cachedPath;
+      warn(`Cached binary at ${cachedPath} reports ${cachedVersion ?? "no version"}, expected ${version}; refreshing from npm package`);
+    }
+    mkdirSync2(versionedDir, { recursive: true });
+    const tmpPath = `${cachedPath}.${process.pid}.${Date.now()}.tmp`;
+    copyFileSync(npmBinaryPath, tmpPath);
+    if (process.platform !== "win32") {
+      chmodSync2(tmpPath, 493);
+    }
+    renameSync2(tmpPath, cachedPath);
+    log(`Copied npm binary to versioned cache: ${cachedPath}`);
+    return cachedPath;
+  } catch (err) {
+    warn(`Failed to copy binary to cache: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function normalizeBareVersion(version) {
+  return version.startsWith("v") ? version.slice(1) : version;
+}
+function homeDirFromEnv(env) {
+  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir3();
+}
+function cacheDirFromEnv(env) {
+  if (process.platform === "win32") {
+    const base2 = env.LOCALAPPDATA || env.APPDATA || join3(homeDirFromEnv(env), "AppData", "Local");
+    return join3(base2, "aft", "bin");
+  }
+  const base = env.XDG_CACHE_HOME || join3(homeDirFromEnv(env), ".cache");
+  return join3(base, "aft", "bin");
+}
+function cachedBinaryPathFromEnv(version, env, ext) {
+  const binaryPath = join3(cacheDirFromEnv(env), version, `aft${ext}`);
+  return existsSync2(binaryPath) ? binaryPath : null;
+}
+function isExpectedCachedBinary(binaryPath, expectedVersion) {
+  const expected = normalizeBareVersion(expectedVersion);
+  const actual = readBinaryVersion(binaryPath);
+  if (actual === expected)
+    return true;
+  warn(`Cached binary at ${binaryPath} reports ${actual ?? "no version"}, expected ${expected}; skipping cache candidate`);
+  return false;
+}
+function platformKey(platform = process.platform, arch = process.arch) {
+  const archMap = PLATFORM_ARCH_MAP[platform];
+  if (!archMap) {
+    throw new Error(`Unsupported platform: ${platform} (arch: ${arch}). ` + `Supported platforms: ${Object.keys(PLATFORM_ARCH_MAP).join(", ")}`);
+  }
+  const key = archMap[arch];
+  if (!key) {
+    throw new Error(`Unsupported architecture: ${arch} on platform ${platform}. ` + `Supported architectures for ${platform}: ${Object.keys(archMap).join(", ")}`);
+  }
+  return key;
+}
+function findBinarySync(expectedVersion) {
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const env = { ...process.env };
+  const pluginVersion = expectedVersion ?? (() => {
+    try {
+      const req = createRequire2(import.meta.url);
+      return req("../package.json").version;
+    } catch {
+      return null;
+    }
+  })();
+  if (pluginVersion) {
+    const tag = pluginVersion.startsWith("v") ? pluginVersion : `v${pluginVersion}`;
+    const versionCached = cachedBinaryPathFromEnv(tag, env, ext);
+    if (versionCached && isExpectedCachedBinary(versionCached, pluginVersion))
+      return versionCached;
+  }
+  try {
+    const key = platformKey();
+    const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
+    const req = createRequire2(import.meta.url);
+    const resolved = req.resolve(packageBin);
+    if (existsSync2(resolved)) {
+      const npmVersion = readBinaryVersion(resolved);
+      if (npmVersion === null) {
+        warn(`npm platform package binary at ${resolved} did not report a version; skipping (continuing to PATH lookup)`);
+      } else if (pluginVersion && npmVersion !== normalizeBareVersion(pluginVersion)) {
+        warn(`npm platform package binary v${npmVersion} does not match plugin v${pluginVersion}; skipping (continuing to PATH lookup)`);
+      } else {
+        const copied = copyToVersionedCache(resolved, npmVersion);
+        return copied ?? resolved;
+      }
+    }
+  } catch {}
+  try {
+    const whichCmd = process.platform === "win32" ? "where aft" : "which aft";
+    const result = execSync(whichCmd, {
+      encoding: "utf-8",
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (result)
+      return result;
+  } catch {}
+  const cargoPath = join3(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
+  if (existsSync2(cargoPath))
+    return cargoPath;
+  return null;
+}
+async function findBinary(expectedVersion) {
+  const syncResult = findBinarySync(expectedVersion);
+  if (syncResult) {
+    log(`Resolved binary: ${syncResult}`);
+    return syncResult;
+  }
+  log("Binary not found locally, attempting auto-download...");
+  const downloaded = await ensureBinary(expectedVersion);
+  if (downloaded)
+    return downloaded;
+  throw new Error([
+    "Could not find the `aft` binary.",
+    "",
+    "Attempted sources:",
+    "  - Cache directory (~/.cache/aft/bin/)",
+    "  - npm platform package (@cortexkit/aft-<platform>)",
+    "  - PATH lookup (which aft)",
+    "  - ~/.cargo/bin/aft",
+    "  - Auto-download from GitHub releases (failed)",
+    "",
+    "Install it using one of these methods:",
+    "  npm install @cortexkit/aft-opencode        # installs platform-specific binary via npm",
+    "  cargo install agent-file-tools             # from crates.io",
+    "  cargo build --release         # from source (binary at target/release/aft)",
+    "",
+    "Or add the aft directory to your PATH."
+  ].join(`
+`));
+}
+
+// ../aft-bridge/dist/migration.js
+var TARGET_MARKER = ".migrated_from_legacy";
+var DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+function dataHome() {
+  if (process.env.XDG_DATA_HOME)
+    return process.env.XDG_DATA_HOME;
+  if (process.platform === "win32") {
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join4(homeDir(), "AppData", "Local");
+  }
+  return join4(homeDir(), ".local", "share");
+}
+function homeDir() {
+  if (process.platform === "win32")
+    return process.env.USERPROFILE || process.env.HOME || homedir4();
+  return process.env.HOME || homedir4();
+}
+function resolveLegacyStorageRoot(harness) {
+  if (harness === "pi")
+    return join4(homeDir(), ".pi", "agent", "aft");
+  return join4(dataHome(), "opencode", "storage", "plugin", "aft");
+}
+function resolveCortexKitStorageRoot() {
+  return join4(dataHome(), "cortexkit", "aft");
+}
+function tail(value) {
+  if (!value)
+    return "";
+  return value.split(`
+`).slice(-20).join(`
+`).trim();
+}
+function spawnErrorLabel(error2) {
+  const code = "code" in error2 ? String(error2.code ?? "") : "";
+  return [code, error2.message].filter(Boolean).join(": ");
+}
+function migrationLogPath(newRoot, harness, logger) {
+  const desired = join4(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
+  try {
+    mkdirSync3(dirname(desired), { recursive: true });
+    return desired;
+  } catch (err) {
+    const fallback = join4(tmpdir(), `aft-migration-${harness}-${Date.now()}.jsonl`);
+    logger?.warn?.(`Failed to create AFT migration log directory ${dirname(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
+    return fallback;
+  }
+}
+async function ensureStorageMigrated(opts) {
+  const legacyRoot = resolveLegacyStorageRoot(opts.harness);
+  const newRoot = resolveCortexKitStorageRoot();
+  const targetMarker = join4(newRoot, opts.harness, TARGET_MARKER);
+  const info = opts.logger?.info ?? opts.logger?.log;
+  if (existsSync3(targetMarker)) {
+    info?.(`AFT storage already migrated for ${opts.harness}; using ${newRoot}`);
+    return;
+  }
+  if (!existsSync3(legacyRoot)) {
+    info?.(`AFT storage migration skipped for ${opts.harness}: no legacy data at ${legacyRoot}; ` + `using ${newRoot} for fresh install`);
+    return;
+  }
+  const logPath = migrationLogPath(newRoot, opts.harness, opts.logger);
+  const binaryPath = opts.binaryPath ?? await findBinary();
+  const startMs = Date.now();
+  info?.(`AFT storage migration starting for ${opts.harness}: ${legacyRoot} -> ${newRoot} ` + `(binary=${binaryPath}, log=${logPath})`);
+  try {
+    process.stderr.write(`
+[AFT] Migrating ${opts.harness} storage to ${newRoot}.
+` + `[AFT] This may take several minutes for large indexes — please do not close ${opts.harness === "pi" ? "Pi" : "OpenCode"}.
+` + `[AFT] Source: ${legacyRoot}
+` + `[AFT] Log:    ${logPath}
+
+`);
+  } catch {}
+  const result = spawnSync2(binaryPath, [
+    "migrate-storage",
+    "--from",
+    legacyRoot,
+    "--to",
+    newRoot,
+    "--harness",
+    opts.harness,
+    "--log",
+    logPath
+  ], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  });
+  if (!result.error && result.status === 0) {
+    const elapsedMs = Date.now() - startMs;
+    info?.(`AFT storage migration completed for ${opts.harness} in ${elapsedMs}ms (log=${logPath})`);
+    try {
+      process.stderr.write(`[AFT] Migration complete (${(elapsedMs / 1000).toFixed(1)}s).
+
+`);
+    } catch {}
+    return;
+  }
+  const detail = result.error ? `spawn error ${spawnErrorLabel(result.error)}` : result.status === null ? `terminated by signal ${result.signal ?? "unknown"}` : `exit ${result.status}`;
+  const stderrTail = tail(result.stderr);
+  const stdoutTail = tail(result.stdout);
+  throw new Error(`AFT storage migration failed (${detail}). ` + `Harness: ${opts.harness}. Legacy: ${legacyRoot}. Target: ${newRoot}. ` + `See log: ${logPath}. ` + `Plugin load aborted to prevent legacy/new state divergence.` + (stderrTail ? ` Stderr tail: ${stderrTail}` : "") + (stdoutTail ? ` Stdout tail: ${stdoutTail}` : ""));
+}
 // ../aft-bridge/dist/onnx-runtime.js
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync2, copyFileSync, createWriteStream as createWriteStream2, existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, openSync as openSync2, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
-import { dirname, join as join3, relative, resolve } from "node:path";
+import { chmodSync as chmodSync3, closeSync as closeSync2, copyFileSync as copyFileSync2, createWriteStream as createWriteStream2, existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync4, openSync as openSync2, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync as rmSync2, statSync as statSync2, symlinkSync, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join5, relative, resolve } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 var ORT_VERSION = "1.24.4";
@@ -31553,8 +31835,8 @@ function getPlatformInfo() {
   if (!platformMap)
     return null;
   const archMap = PLATFORM_ARCH_MAP[process.platform] ?? {};
-  const platformKey = archMap[process.arch];
-  const ortArch = platformKey ? platformKey.split("-")[1] : process.arch;
+  const platformKey2 = archMap[process.arch];
+  const ortArch = platformKey2 ? platformKey2.split("-")[1] : process.arch;
   return platformMap[ortArch] || null;
 }
 function getManualInstallHint() {
@@ -31568,9 +31850,9 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortDir = join3(storageDir, "onnxruntime", ORT_VERSION);
-  const libPath = join3(ortDir, info?.libName ?? "libonnxruntime.dylib");
-  if (existsSync2(libPath)) {
+  const ortDir = join5(storageDir, "onnxruntime", ORT_VERSION);
+  const libPath = join5(ortDir, info?.libName ?? "libonnxruntime.dylib");
+  if (existsSync4(libPath)) {
     const meta = readOnnxInstalledMeta(ortDir);
     if (meta?.sha256) {
       try {
@@ -31599,9 +31881,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join3(storageDir, "onnxruntime");
-  mkdirSync2(onnxBaseDir, { recursive: true });
-  const lockPath = join3(onnxBaseDir, ONNX_LOCK_FILE);
+  const onnxBaseDir = join5(storageDir, "onnxruntime");
+  mkdirSync4(onnxBaseDir, { recursive: true });
+  const lockPath = join5(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -31620,7 +31902,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join3(onnxBaseDir, entry);
+      const stagingDir = join5(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -31652,7 +31934,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync2(ortDir) && !existsSync2(join3(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync4(ortDir) && !existsSync4(join5(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync2(ortDir, { recursive: true, force: true });
     }
@@ -31673,8 +31955,8 @@ function detectOnnxVersion(libDir, libName) {
       if (match)
         return match[1];
     }
-    const base = join3(libDir, libName);
-    if (existsSync2(base)) {
+    const base = join5(libDir, libName);
+    if (existsSync4(base)) {
       try {
         const real = realpathSync(base);
         const m = real.match(/\.(\d+\.\d+\.\d+)(?:\.dylib)?$/);
@@ -31710,7 +31992,7 @@ function findSystemOnnxRuntime(libName) {
     searchPaths.push("/usr/lib", "/usr/lib/x86_64-linux-gnu", "/usr/lib/aarch64-linux-gnu", "/usr/local/lib");
   }
   for (const dir of searchPaths) {
-    if (!existsSync2(join3(dir, libName)))
+    if (!existsSync4(join5(dir, libName)))
       continue;
     const version = detectOnnxVersion(dir, libName);
     if (version && !isOnnxVersionCompatible(version)) {
@@ -31737,7 +32019,7 @@ async function downloadFileWithCap(url, destPath) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
     }
-    mkdirSync2(dirname(destPath), { recursive: true });
+    mkdirSync4(dirname2(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
@@ -31767,11 +32049,11 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync(dir);
     for (const entry of entries) {
-      const fullPath = join3(dir, entry);
+      const fullPath = join5(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve(dirname(fullPath), linkTarget);
+        const resolvedTarget = resolve(dirname2(fullPath), linkTarget);
         const rel2 = relative(realRoot, resolvedTarget);
         if (rel2.startsWith("..") || process.platform !== "win32" && rel2.startsWith("/")) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
@@ -31801,8 +32083,8 @@ async function downloadOnnxRuntime(info, targetDir) {
   log(`Downloading ONNX Runtime v${ORT_VERSION} for ${process.platform}/${process.arch}...`);
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
   try {
-    mkdirSync2(tmpDir, { recursive: true });
-    const archivePath = join3(tmpDir, `onnxruntime.${info.archiveType}`);
+    mkdirSync4(tmpDir, { recursive: true });
+    const archivePath = join5(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
@@ -31818,16 +32100,16 @@ async function downloadOnnxRuntime(info, targetDir) {
       unlinkSync2(archivePath);
     } catch {}
     validateExtractedTree(tmpDir);
-    const extractedDir = join3(tmpDir, info.assetName, "lib");
-    if (!existsSync2(extractedDir)) {
+    const extractedDir = join5(tmpDir, info.assetName, "lib");
+    if (!existsSync4(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
-    mkdirSync2(targetDir, { recursive: true });
+    mkdirSync4(targetDir, { recursive: true });
     const libFiles = readdirSync(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join3(extractedDir, libFile);
+      const src = join5(extractedDir, libFile);
       try {
         const stat = lstatSync(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
@@ -31842,7 +32124,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join3(targetDir, info.libName);
+    const libPath = join5(targetDir, info.libName);
     let libHash = null;
     try {
       libHash = sha256File(libPath);
@@ -31864,15 +32146,15 @@ async function downloadOnnxRuntime(info, targetDir) {
     return null;
   }
 }
-function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync) {
+function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync2) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = join3(extractedDir, libFile);
-    const dst = join3(targetDir, libFile);
+    const src = join5(extractedDir, libFile);
+    const dst = join5(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
-        chmodSync2(dst, 493);
+        chmodSync3(dst, 493);
       }
     } catch (copyErr) {
       if (requiredLibs.has(libFile)) {
@@ -31883,7 +32165,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
     }
   }
   for (const link of symlinks) {
-    const dst = join3(targetDir, link.name);
+    const dst = join5(targetDir, link.name);
     try {
       unlinkSync2(dst);
     } catch {}
@@ -31897,8 +32179,8 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join3(targetDir, info.libName);
-  if (!existsSync2(requiredPath)) {
+  const requiredPath = join5(targetDir, info.libName);
+  if (!existsSync4(requiredPath)) {
     rmSync2(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
   }
@@ -31924,13 +32206,13 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync(join3(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync(join5(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
   } catch (err) {
     log(`[onnx] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readOnnxInstalledMeta(installDir) {
-  const path = join3(installDir, ONNX_INSTALLED_META_FILE);
+  const path = join5(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync2(path).isFile())
       return null;
@@ -32045,13 +32327,13 @@ function isProcessAlive(pid) {
 }
 // ../aft-bridge/dist/pool.js
 import { realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 var DEFAULT_IDLE_TIMEOUT_MS = Infinity;
 var DEFAULT_MAX_POOL_SIZE = 8;
 var CLEANUP_INTERVAL_MS = 60 * 1000;
 function canonicalHomeDir() {
   try {
-    const home = homedir3();
+    const home = homedir5();
     if (!home)
       return null;
     try {
@@ -32077,6 +32359,7 @@ class BridgePool {
   idleTimeoutMs;
   bridgeOptions;
   configOverrides;
+  projectConfigLoader;
   logger;
   cleanupTimer = null;
   constructor(binaryPath, options = {}, configOverrides = {}) {
@@ -32084,6 +32367,7 @@ class BridgePool {
     this.maxPoolSize = options.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE;
     this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
     this.logger = options.logger;
+    this.projectConfigLoader = options.projectConfigLoader;
     this.bridgeOptions = {
       timeoutMs: options.timeoutMs,
       maxRestarts: options.maxRestarts,
@@ -32119,7 +32403,17 @@ class BridgePool {
     if (this.bridges.size >= this.maxPoolSize) {
       this.evictLRU();
     }
-    const bridge = new BinaryBridge(this.binaryPath, key, this.bridgeOptions, this.configOverrides);
+    let projectOverrides = {};
+    if (this.projectConfigLoader) {
+      try {
+        projectOverrides = this.projectConfigLoader(key) ?? {};
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.error(`projectConfigLoader failed; using global overrides only: ${message}`);
+      }
+    }
+    const mergedOverrides = { ...this.configOverrides, ...projectOverrides };
+    const bridge = new BinaryBridge(this.binaryPath, key, this.bridgeOptions, mergedOverrides);
     this.bridges.set(key, { bridge, lastUsed: Date.now() });
     return bridge;
   }
@@ -32212,180 +32506,12 @@ function normalizeKey(projectRoot) {
     return stripped;
   }
 }
-// ../aft-bridge/dist/resolver.js
-import { execSync, spawnSync } from "node:child_process";
-import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync3, renameSync as renameSync2 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
-function readBinaryVersion(binaryPath) {
-  try {
-    const result = spawnSync(binaryPath, ["--version"], {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5000
-    });
-    const stdoutVersion = result.stdout?.trim();
-    const stderrVersion = result.stderr?.trim();
-    const rawVersion = stdoutVersion || stderrVersion;
-    if (!rawVersion)
-      return null;
-    return rawVersion.replace(/^aft\s+/, "");
-  } catch {
-    return null;
-  }
-}
-function copyToVersionedCache(npmBinaryPath, knownVersion) {
-  try {
-    const version = knownVersion ?? readBinaryVersion(npmBinaryPath);
-    if (!version)
-      return null;
-    const tag = version.startsWith("v") ? version : `v${version}`;
-    const cacheDir = getCacheDir();
-    const versionedDir = join4(cacheDir, tag);
-    const ext = process.platform === "win32" ? ".exe" : "";
-    const cachedPath = join4(versionedDir, `aft${ext}`);
-    if (existsSync3(cachedPath)) {
-      const cachedVersion = readBinaryVersion(cachedPath);
-      if (cachedVersion === version)
-        return cachedPath;
-      warn(`Cached binary at ${cachedPath} reports ${cachedVersion ?? "no version"}, expected ${version}; refreshing from npm package`);
-    }
-    mkdirSync3(versionedDir, { recursive: true });
-    const tmpPath = `${cachedPath}.${process.pid}.${Date.now()}.tmp`;
-    copyFileSync2(npmBinaryPath, tmpPath);
-    if (process.platform !== "win32") {
-      chmodSync3(tmpPath, 493);
-    }
-    renameSync2(tmpPath, cachedPath);
-    log(`Copied npm binary to versioned cache: ${cachedPath}`);
-    return cachedPath;
-  } catch (err) {
-    warn(`Failed to copy binary to cache: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
-  }
-}
-function normalizeBareVersion(version) {
-  return version.startsWith("v") ? version.slice(1) : version;
-}
-function homeDirFromEnv(env) {
-  return (process.platform === "win32" ? env.USERPROFILE || env.HOME : env.HOME) || homedir4();
-}
-function cacheDirFromEnv(env) {
-  if (process.platform === "win32") {
-    const base2 = env.LOCALAPPDATA || env.APPDATA || join4(homeDirFromEnv(env), "AppData", "Local");
-    return join4(base2, "aft", "bin");
-  }
-  const base = env.XDG_CACHE_HOME || join4(homeDirFromEnv(env), ".cache");
-  return join4(base, "aft", "bin");
-}
-function cachedBinaryPathFromEnv(version, env, ext) {
-  const binaryPath = join4(cacheDirFromEnv(env), version, `aft${ext}`);
-  return existsSync3(binaryPath) ? binaryPath : null;
-}
-function isExpectedCachedBinary(binaryPath, expectedVersion) {
-  const expected = normalizeBareVersion(expectedVersion);
-  const actual = readBinaryVersion(binaryPath);
-  if (actual === expected)
-    return true;
-  warn(`Cached binary at ${binaryPath} reports ${actual ?? "no version"}, expected ${expected}; skipping cache candidate`);
-  return false;
-}
-function platformKey(platform = process.platform, arch = process.arch) {
-  const archMap = PLATFORM_ARCH_MAP[platform];
-  if (!archMap) {
-    throw new Error(`Unsupported platform: ${platform} (arch: ${arch}). ` + `Supported platforms: ${Object.keys(PLATFORM_ARCH_MAP).join(", ")}`);
-  }
-  const key = archMap[arch];
-  if (!key) {
-    throw new Error(`Unsupported architecture: ${arch} on platform ${platform}. ` + `Supported architectures for ${platform}: ${Object.keys(archMap).join(", ")}`);
-  }
-  return key;
-}
-function findBinarySync(expectedVersion) {
-  const ext = process.platform === "win32" ? ".exe" : "";
-  const env = { ...process.env };
-  const pluginVersion = expectedVersion ?? (() => {
-    try {
-      const req = createRequire2(import.meta.url);
-      return req("../package.json").version;
-    } catch {
-      return null;
-    }
-  })();
-  if (pluginVersion) {
-    const tag = pluginVersion.startsWith("v") ? pluginVersion : `v${pluginVersion}`;
-    const versionCached = cachedBinaryPathFromEnv(tag, env, ext);
-    if (versionCached && isExpectedCachedBinary(versionCached, pluginVersion))
-      return versionCached;
-  }
-  try {
-    const key = platformKey();
-    const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
-    const req = createRequire2(import.meta.url);
-    const resolved = req.resolve(packageBin);
-    if (existsSync3(resolved)) {
-      const npmVersion = readBinaryVersion(resolved);
-      if (npmVersion === null) {
-        warn(`npm platform package binary at ${resolved} did not report a version; skipping (continuing to PATH lookup)`);
-      } else if (pluginVersion && npmVersion !== normalizeBareVersion(pluginVersion)) {
-        warn(`npm platform package binary v${npmVersion} does not match plugin v${pluginVersion}; skipping (continuing to PATH lookup)`);
-      } else {
-        const copied = copyToVersionedCache(resolved, npmVersion);
-        return copied ?? resolved;
-      }
-    }
-  } catch {}
-  try {
-    const whichCmd = process.platform === "win32" ? "where aft" : "which aft";
-    const result = execSync(whichCmd, {
-      encoding: "utf-8",
-      env,
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (result)
-      return result;
-  } catch {}
-  const cargoPath = join4(homeDirFromEnv(env), ".cargo", "bin", `aft${ext}`);
-  if (existsSync3(cargoPath))
-    return cargoPath;
-  return null;
-}
-async function findBinary(expectedVersion) {
-  const syncResult = findBinarySync(expectedVersion);
-  if (syncResult) {
-    log(`Resolved binary: ${syncResult}`);
-    return syncResult;
-  }
-  log("Binary not found locally, attempting auto-download...");
-  const downloaded = await ensureBinary(expectedVersion);
-  if (downloaded)
-    return downloaded;
-  throw new Error([
-    "Could not find the `aft` binary.",
-    "",
-    "Attempted sources:",
-    "  - Cache directory (~/.cache/aft/bin/)",
-    "  - npm platform package (@cortexkit/aft-<platform>)",
-    "  - PATH lookup (which aft)",
-    "  - ~/.cargo/bin/aft",
-    "  - Auto-download from GitHub releases (failed)",
-    "",
-    "Install it using one of these methods:",
-    "  npm install @cortexkit/aft-opencode        # installs platform-specific binary via npm",
-    "  cargo install agent-file-tools             # from crates.io",
-    "  cargo build --release         # from source (binary at target/release/aft)",
-    "",
-    "Or add the aft directory to your PATH."
-  ].join(`
-`));
-}
 // ../aft-bridge/dist/url-fetch.js
 import { createHash as createHash3 } from "node:crypto";
 import { lookup } from "node:dns/promises";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { isIP } from "node:net";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // ../../node_modules/.bun/undici@8.2.0/node_modules/undici/index.js
 var __filename = "/home/runner/work/aft/aft/node_modules/.bun/undici@8.2.0/node_modules/undici/index.js";
@@ -32535,16 +32661,16 @@ var CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 var FETCH_TIMEOUT_MS = 30000;
 var MAX_REDIRECTS = 5;
 function cacheDir(storageDir) {
-  return join5(storageDir, "url_cache");
+  return join6(storageDir, "url_cache");
 }
 function hashUrl(url) {
   return createHash3("sha256").update(url).digest("hex").slice(0, 16);
 }
 function metaPath(storageDir, hash) {
-  return join5(cacheDir(storageDir), `${hash}.meta.json`);
+  return join6(cacheDir(storageDir), `${hash}.meta.json`);
 }
 function contentPath(storageDir, hash, extension) {
-  return join5(cacheDir(storageDir), `${hash}${extension}`);
+  return join6(cacheDir(storageDir), `${hash}${extension}`);
 }
 function _isPrivateIpv4(address) {
   const parts = address.split(".").map((part) => Number.parseInt(part, 10));
@@ -32562,9 +32688,9 @@ function expandIpv6(addr) {
   let normalized = addr;
   const lastColon = normalized.lastIndexOf(":");
   if (lastColon !== -1) {
-    const tail = normalized.slice(lastColon + 1);
-    if (tail.includes(".")) {
-      const octets = tail.split(".").map((p) => Number.parseInt(p, 10));
+    const tail2 = normalized.slice(lastColon + 1);
+    if (tail2.includes(".")) {
+      const octets = tail2.split(".").map((p) => Number.parseInt(p, 10));
       if (octets.length !== 4 || octets.some((o) => Number.isNaN(o) || o < 0 || o > 255)) {
         return null;
       }
@@ -32742,15 +32868,15 @@ async function fetchUrlToTempFile(url, storageDir, options = {}) {
   const allowPrivate = options.allowPrivate === true;
   await assertPublicUrl(parsed, allowPrivate, options.lookup);
   const dir = cacheDir(storageDir);
-  mkdirSync4(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true });
   const hash = hashUrl(url);
   const metaFile = metaPath(storageDir, hash);
-  if (existsSync4(metaFile)) {
+  if (existsSync5(metaFile)) {
     try {
       const meta2 = JSON.parse(readFileSync2(metaFile, "utf8"));
       const age = Date.now() - meta2.fetchedAt;
       const cached = contentPath(storageDir, hash, meta2.extension);
-      if (age < CACHE_TTL_MS && existsSync4(cached)) {
+      if (age < CACHE_TTL_MS && existsSync5(cached)) {
         log(`URL cache hit: ${url} (${Math.round(age / 1000)}s old)`);
         return cached;
       }
@@ -33056,12 +33182,12 @@ function formatSystemReminder(completions) {
   const bullets = completions.map((completion) => formatCompletion(completion)).join(`
 `);
   const anyTruncated = completions.some((c) => c.output_truncated === true);
-  const tail = anyTruncated ? `
+  const tail2 = anyTruncated ? `
 
 For truncated tasks, use bash_status({ task_id: "..." }) to retrieve full output.` : "";
   return `<system-reminder>
 [BACKGROUND BASH COMPLETED]
-${bullets}${tail}
+${bullets}${tail2}
 </system-reminder>`;
 }
 function formatLongRunningReminder(reminders) {
@@ -33299,7 +33425,7 @@ import {
 // package.json
 var package_default = {
   name: "@cortexkit/aft-pi",
-  version: "0.26.4",
+  version: "0.27.1",
   type: "module",
   description: "Pi coding agent extension for Agent File Tools (AFT) — tree-sitter and LSP-powered code analysis",
   main: "dist/index.js",
@@ -33321,18 +33447,18 @@ var package_default = {
     prepublishOnly: "bun run build"
   },
   dependencies: {
-    "@cortexkit/aft-bridge": "0.26.4",
+    "@cortexkit/aft-bridge": "0.27.1",
     typebox: "^1.1.24",
     "comment-json": "^5.0.0",
     diff: "^8.0.4",
     zod: "^4.1.8"
   },
   optionalDependencies: {
-    "@cortexkit/aft-darwin-arm64": "0.26.4",
-    "@cortexkit/aft-darwin-x64": "0.26.4",
-    "@cortexkit/aft-linux-arm64": "0.26.4",
-    "@cortexkit/aft-linux-x64": "0.26.4",
-    "@cortexkit/aft-win32-x64": "0.26.4"
+    "@cortexkit/aft-darwin-arm64": "0.27.1",
+    "@cortexkit/aft-darwin-x64": "0.27.1",
+    "@cortexkit/aft-linux-arm64": "0.27.1",
+    "@cortexkit/aft-linux-x64": "0.27.1",
+    "@cortexkit/aft-win32-x64": "0.27.1"
   },
   devDependencies: {
     "@earendil-works/pi-coding-agent": "*",
@@ -33377,6 +33503,24 @@ function readNumber(value, fallback = 0) {
 function readOptionalNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
+function readCompressionAggregate(value) {
+  const aggregate = asRecord(value);
+  return {
+    events: readNumber(aggregate.events),
+    original_tokens: readNumber(aggregate.original_tokens),
+    compressed_tokens: readNumber(aggregate.compressed_tokens),
+    savings_tokens: readNumber(aggregate.savings_tokens)
+  };
+}
+function readCompression(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  const compression = asRecord(value);
+  return {
+    project: readCompressionAggregate(compression.project),
+    session: readCompressionAggregate(compression.session)
+  };
+}
 function formatFlag(enabled) {
   return enabled ? "enabled" : "disabled";
 }
@@ -33452,7 +33596,8 @@ function coerceAftStatus(response) {
       id: readString(session.id, "__default__"),
       tracked_files: readNumber(session.tracked_files),
       checkpoints: readNumber(session.checkpoints)
-    }
+    },
+    compression: readCompression(response.compression)
   };
 }
 function formatStatusDialogMessage(status) {
@@ -33688,6 +33833,13 @@ function renderInner(s, error3, theme, innerWidth) {
   lines.push("");
   lines.push(theme.fg("muted", "Features"));
   lines.push(`  ${featureBadge("format_on_edit", s.features.format_on_edit, theme)}  ${featureBadge("search_index", s.features.search_index, theme)}  ${featureBadge("semantic_search", s.features.semantic_search, theme)}`);
+  const compressionRows = formatCompressionStatusRows(s.compression);
+  if (compressionRows.length > 0) {
+    lines.push("");
+    lines.push(theme.fg("muted", "Compression"));
+    for (const row of compressionRows)
+      lines.push(row);
+  }
   if (s.semantic_index.stage) {
     lines.push("");
     lines.push(theme.fg("muted", "Semantic build progress"));
@@ -33711,6 +33863,23 @@ function renderInner(s, error3, theme, innerWidth) {
   lines.push(theme.fg("muted", "Press Escape to close"));
   return lines;
 }
+function appendCompressionScope(rows, label, aggregate) {
+  const pct = compressionSavingsPercent(aggregate.original_tokens, aggregate.compressed_tokens);
+  const savings = aggregate.savings_tokens;
+  rows.push(label);
+  rows.push(`  Tokens Saved        ${savings.toLocaleString("en-US")}`);
+  rows.push(`  Compression Ratio   ${pct ?? 0}%`);
+}
+function formatCompressionStatusRows(compression) {
+  if (!compression || compression.project.events <= 0)
+    return [];
+  const rows = [];
+  if (compression.session.events > 0) {
+    appendCompressionScope(rows, "Session", compression.session);
+  }
+  appendCompressionScope(rows, "Project", compression.project);
+  return rows;
+}
 function colorStatus(status, theme) {
   switch (status) {
     case "ready":
@@ -33817,9 +33986,9 @@ function registerStatusCommand(pi, ctx) {
 
 // src/config.ts
 var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync5, readFileSync as readFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync3, renameSync as renameSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join8 } from "node:path";
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -47417,6 +47586,7 @@ var ExperimentalConfigSchema = exports_external.object({
   lsp_ty: exports_external.boolean().optional()
 });
 var AftConfigSchema = exports_external.object({
+  $schema: exports_external.string().optional(),
   format_on_edit: exports_external.boolean().optional(),
   formatter_timeout_secs: exports_external.number().int().min(1).max(600).optional(),
   validate_on_edit: exports_external.enum(["syntax", "full"]).optional(),
@@ -47569,7 +47739,7 @@ function migrateRawConfig(rawConfig, configPath, logger) {
   return oldKeys;
 }
 function migrateAftConfigFile(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync5(configPath)) {
+  if (!existsSync6(configPath)) {
     return { migrated: false, oldKeys: [] };
   }
   let tmpPath = null;
@@ -47612,15 +47782,15 @@ ${serialized}` : serialized;
 function detectConfigFile(basePath) {
   const jsoncPath = `${basePath}.jsonc`;
   const jsonPath = `${basePath}.json`;
-  if (existsSync5(jsoncPath))
+  if (existsSync6(jsoncPath))
     return { format: "jsonc", path: jsoncPath };
-  if (existsSync5(jsonPath))
+  if (existsSync6(jsonPath))
     return { format: "json", path: jsonPath };
   return { format: "none", path: jsonPath };
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync5(configPath))
+    if (!existsSync6(configPath))
       return null;
     const content = readFileSync3(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
@@ -47773,15 +47943,15 @@ function mergeConfigs(base, override) {
   };
 }
 function getGlobalPiDir() {
-  return join7(homedir5(), ".pi", "agent");
+  return join8(homedir6(), ".pi", "agent");
 }
 function loadAftConfig(projectDirectory) {
-  const userBasePath = join7(getGlobalPiDir(), "aft");
+  const userBasePath = join8(getGlobalPiDir(), "aft");
   migrateAftConfigFile(`${userBasePath}.jsonc`);
   migrateAftConfigFile(`${userBasePath}.json`);
   const userDetected = detectConfigFile(userBasePath);
   const userConfigPath = userDetected.format !== "none" ? userDetected.path : `${userBasePath}.json`;
-  const projectBasePath = join7(projectDirectory, ".pi", "aft");
+  const projectBasePath = join8(projectDirectory, ".pi", "aft");
   migrateAftConfigFile(`${projectBasePath}.jsonc`);
   migrateAftConfigFile(`${projectBasePath}.json`);
   const projectDetected = detectConfigFile(projectBasePath);
@@ -47808,49 +47978,49 @@ function loadAftConfig(projectDirectory) {
 // src/lsp-auto-install.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { createReadStream, mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
-import { join as join10 } from "node:path";
+import { createReadStream, mkdirSync as mkdirSync7, readFileSync as readFileSync5, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync4 } from "node:fs";
+import { join as join11 } from "node:path";
 
 // src/lsp-cache.ts
 import {
   closeSync as closeSync3,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync6,
   openSync as openSync3,
   readFileSync as readFileSync4,
   statSync as statSync3,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join8 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { join as join9 } from "node:path";
 function aftCacheBase() {
   const override = process.env.AFT_CACHE_DIR;
   if (override && override.length > 0)
     return override;
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join8(homedir6(), "AppData", "Local");
-    return join8(base2, "aft");
+    const base2 = localAppData || join9(homedir7(), "AppData", "Local");
+    return join9(base2, "aft");
   }
-  const base = process.env.XDG_CACHE_HOME || join8(homedir6(), ".cache");
-  return join8(base, "aft");
+  const base = process.env.XDG_CACHE_HOME || join9(homedir7(), ".cache");
+  return join9(base, "aft");
 }
 function lspCacheRoot() {
-  return join8(aftCacheBase(), "lsp-packages");
+  return join9(aftCacheBase(), "lsp-packages");
 }
 function lspPackageDir(npmPackage) {
-  return join8(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join9(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join8(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join9(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join8(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join9(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync3(join8(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync3(join9(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -47864,19 +48034,19 @@ function lspBinaryCandidates(binary) {
 var INSTALLED_META_FILE = ".aft-installed";
 function writeInstalledMetaIn(installDir, version2, sha256) {
   try {
-    mkdirSync5(installDir, { recursive: true });
+    mkdirSync6(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync4(join8(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+    writeFileSync4(join9(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path2 = join8(installDir, INSTALLED_META_FILE);
+  const path2 = join9(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync3(path2).isFile())
       return null;
@@ -47900,11 +48070,11 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join8(lspPackageDir(npmPackage), ".aft-installing");
+  return join9(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
-  mkdirSync5(lspPackageDir(lockKey), { recursive: true });
+  mkdirSync6(lspPackageDir(lockKey), { recursive: true });
   const lock = lockPath(lockKey);
   const tryClaim = () => {
     try {
@@ -48007,7 +48177,7 @@ async function withInstallLock(lockKey, task) {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file2 = join8(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file2 = join9(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync4(file2, "utf8");
     const parsed = JSON.parse(raw);
@@ -48023,8 +48193,8 @@ function readVersionCheck(npmPackage) {
   }
 }
 function writeVersionCheck(npmPackage, latest) {
-  mkdirSync5(lspPackageDir(npmPackage), { recursive: true });
-  const file2 = join8(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  mkdirSync6(lspPackageDir(npmPackage), { recursive: true });
+  const file2 = join9(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record2 = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -48172,8 +48342,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync6, readdirSync as readdirSync3 } from "node:fs";
-import { join as join9 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync3 } from "node:fs";
+import { join as join10 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -48190,7 +48360,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync6(join9(projectRoot, marker)))
+    if (existsSync7(join10(projectRoot, marker)))
       return true;
   }
   return false;
@@ -48216,7 +48386,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
-          queue.push({ dir: join9(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join10(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -48514,10 +48684,10 @@ function sha256OfFileSync(path2) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join10(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join11(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync6(join10(dest, ".."), { recursive: true });
+    mkdirSync7(join11(dest, ".."), { recursive: true });
     rmSync3(dest, { recursive: true, force: true });
     renameSync4(packageDir, dest);
   } catch (err) {
@@ -48600,9 +48770,9 @@ import {
   copyFileSync as copyFileSync3,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   readdirSync as readdirSync4,
   readFileSync as readFileSync6,
   readlinkSync as readlinkSync2,
@@ -48613,7 +48783,7 @@ import {
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { dirname as dirname2, join as join11, relative as relative2, resolve as resolve2 } from "node:path";
+import { dirname as dirname3, join as join12, relative as relative2, resolve as resolve2 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -48703,26 +48873,26 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join11(aftCacheBase(), "lsp-binaries");
+  return join12(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join11(ghCacheRoot(), spec.id);
+  return join12(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join11(ghPackageDir(spec), "bin");
+  return join12(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join11(ghPackageDir(spec), "extracted");
+  return join12(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return join11(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join12(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync5(join11(ghBinDir(spec), candidate)).isFile())
+      if (statSync5(join12(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -48735,7 +48905,7 @@ function ghBinaryCandidates(spec, platform) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path2 = join11(installDir, INSTALLED_META_FILE2);
+    const path2 = join12(installDir, INSTALLED_META_FILE2);
     if (!statSync5(path2).isFile())
       return null;
     const parsed = JSON.parse(readFileSync6(path2, "utf8"));
@@ -48754,7 +48924,7 @@ function readGithubInstalledMetaIn(installDir) {
 }
 function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveSha256) {
   try {
-    mkdirSync7(installDir, { recursive: true });
+    mkdirSync8(installDir, { recursive: true });
     const meta3 = {
       version: version2,
       installedAt: new Date().toISOString(),
@@ -48762,7 +48932,7 @@ function writeGithubInstalledMetaIn(installDir, version2, binarySha256, archiveS
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync5(join11(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
+    writeFileSync5(join12(installDir, INSTALLED_META_FILE2), JSON.stringify(meta3), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -48955,7 +49125,7 @@ async function downloadFile(url2, destPath, fetchImpl2, assetSize, signal) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES3) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES3}`);
     }
-    mkdirSync7(dirname2(destPath), { recursive: true });
+    mkdirSync8(dirname3(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -49011,7 +49181,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join11(dir, entry);
+      const full = join12(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -49081,7 +49251,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
   try {
     rmSync4(stagingDir, { recursive: true, force: true });
   } catch {}
-  mkdirSync7(stagingDir, { recursive: true });
+  mkdirSync8(stagingDir, { recursive: true });
   try {
     precheckArchiveContents(archivePath, archiveType);
     runPlatformExtractor(archivePath, stagingDir, archiveType);
@@ -49099,10 +49269,10 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join11(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join12(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync7(dirname2(dest), { recursive: true });
+    mkdirSync8(dirname3(dest), { recursive: true });
     rmSync4(dest, { recursive: true, force: true });
     renameSync5(packageDir, dest);
   } catch (err) {
@@ -49112,7 +49282,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform) {
   const packageDir = ghPackageDir(spec);
   const meta3 = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join11(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join12(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync5(candidate).isFile();
     } catch {
@@ -49190,7 +49360,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join11(pkgDir, expected.name);
+  const archivePath = join12(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl2, matchingAsset.size, signal);
@@ -49230,13 +49400,13 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2,
       unlinkSync6(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join11(extractDir, spec.binaryPathInArchive(platform, arch, version2));
-  if (!existsSync7(innerBinaryPath)) {
+  const innerBinaryPath = join12(extractDir, spec.binaryPathInArchive(platform, arch, version2));
+  if (!existsSync8(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
   const targetBinary = ghBinaryPath(spec, platform);
-  mkdirSync7(dirname2(targetBinary), { recursive: true });
+  mkdirSync8(dirname3(targetBinary), { recursive: true });
   try {
     copyFileSync3(innerBinaryPath, targetBinary);
     if (platform !== "win32") {
@@ -49315,7 +49485,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl2 = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync7(ghBinDir(spec))) {
+        if (existsSync8(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -49413,11 +49583,10 @@ function discoverRelevantGithubServers(projectRoot) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, renameSync as renameSync6, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join13 } from "node:path";
 var WARNING_MARKER = "\uD83D\uDD27 AFT: ⚠️";
 var FEATURE_MARKER = "\uD83D\uDD27 AFT: ✨";
-var WARNED_TOOLS_FILE = "warned_tools.json";
 function sendIgnoredMessage(client, sessionId, text) {
   const typedClient = client;
   if (typeof typedClient.ui?.notify !== "function")
@@ -49430,55 +49599,36 @@ function sendIgnoredMessage(client, sessionId, text) {
     return false;
   }
 }
-function readWarnedTools(storageDir) {
+async function readWarnedTools(bridge) {
   try {
-    const warnedToolsPath = join12(storageDir, WARNED_TOOLS_FILE);
-    if (!existsSync8(warnedToolsPath))
+    const resp = await bridge.send("db_get_state", { key: "warned_tools" });
+    if (resp.success === false)
+      return {};
+    const value = resp.data?.value;
+    if (typeof value !== "string")
       return {};
-    const parsed = JSON.parse(readFileSync7(warnedToolsPath, "utf-8"));
+    const parsed = JSON.parse(value);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
-    const warned = {};
-    for (const [key, version2] of Object.entries(parsed)) {
-      if (typeof version2 === "string") {
-        warned[key] = version2;
-      }
-    }
-    return warned;
+    return parsed;
   } catch {
     return {};
   }
 }
-function writeWarnedTools(storageDir, warned) {
+async function hasWarnedFor(bridge, key) {
+  const warned = await readWarnedTools(bridge);
+  return warned[key] === true || typeof warned[key] === "string";
+}
+async function recordWarning(bridge, key) {
+  const warned = await readWarnedTools(bridge);
+  warned[key] = true;
   try {
-    mkdirSync8(storageDir, { recursive: true });
-    const warnedToolsPath = join12(storageDir, WARNED_TOOLS_FILE);
-    const tmpPath = join12(storageDir, `${WARNED_TOOLS_FILE}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
-    writeFileSync6(tmpPath, `${JSON.stringify(warned, null, 2)}
-`);
-    renameSync6(tmpPath, warnedToolsPath);
+    await bridge.send("db_set_state", {
+      key: "warned_tools",
+      value: JSON.stringify(warned)
+    });
   } catch {}
 }
-async function withWarnedToolsLock(storageDir, fn) {
-  const lockDir = join12(storageDir, "warned_tools.lock");
-  for (let attempt = 0;attempt < 5; attempt++) {
-    try {
-      mkdirSync8(storageDir, { recursive: true });
-      mkdirSync8(lockDir, { mode: 448 });
-      try {
-        return await fn();
-      } finally {
-        rmSync5(lockDir, { recursive: true, force: true });
-      }
-    } catch (err) {
-      const code = err.code;
-      if (code !== "EEXIST")
-        return null;
-      await new Promise((resolve3) => setTimeout(resolve3, 10 * (attempt + 1)));
-    }
-  }
-  return null;
-}
 function warningKey(warning, projectRoot) {
   const scope = warning.kind === "lsp_binary_missing" ? "_" : projectRoot ?? "_";
   return [
@@ -49517,35 +49667,19 @@ ${warning.hint}`;
 async function deliverConfigureWarnings(opts, warnings) {
   if (warnings.length === 0)
     return;
-  const deliveredWithLock = await withWarnedToolsLock(opts.storageDir, async () => {
-    const warned = readWarnedTools(opts.storageDir);
-    let changed = false;
-    for (const warning of warnings) {
-      const key = warningKey(warning, opts.projectRoot);
-      if (Object.hasOwn(warned, key))
-        continue;
-      if (!sendIgnoredMessage(opts.client, opts.sessionId, formatConfigureWarning(warning))) {
-        continue;
-      }
-      warned[key] = opts.pluginVersion;
-      changed = true;
-    }
-    if (changed) {
-      const merged = { ...readWarnedTools(opts.storageDir), ...warned };
-      writeWarnedTools(opts.storageDir, merged);
-    }
-    return true;
-  });
-  if (deliveredWithLock)
-    return;
   for (const warning of warnings) {
-    sendIgnoredMessage(opts.client, opts.sessionId, formatConfigureWarning(warning));
+    const key = warningKey(warning, opts.projectRoot);
+    if (await hasWarnedFor(opts.bridge, key))
+      continue;
+    if (!sendIgnoredMessage(opts.client, opts.sessionId, formatConfigureWarning(warning)))
+      continue;
+    await recordWarning(opts.bridge, key);
   }
 }
 function sendFeatureAnnouncement(version2, features, storageDir) {
-  const versionFile = join12(storageDir, "last_announced_version");
+  const versionFile = join13(storageDir, "last_announced_version");
   try {
-    if (existsSync8(versionFile)) {
+    if (existsSync9(versionFile)) {
       const lastVersion = readFileSync7(versionFile, "utf-8").trim();
       if (lastVersion === version2)
         return;
@@ -49554,7 +49688,7 @@ function sendFeatureAnnouncement(version2, features, storageDir) {
   log2([`${FEATURE_MARKER} v${version2}:`, ...features.map((feature) => `  • ${feature}`)].join(`
 `));
   try {
-    mkdirSync8(storageDir, { recursive: true });
+    mkdirSync9(storageDir, { recursive: true });
     writeFileSync6(versionFile, version2);
   } catch {}
 }
@@ -49616,7 +49750,7 @@ import { StringEnum } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 
 // src/tools/render-helpers.ts
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { renderDiff } from "@earendil-works/pi-coding-agent";
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 function reuseText(last) {
@@ -49626,7 +49760,7 @@ function reuseContainer(last) {
   return last instanceof Container ? last : new Container;
 }
 function shortenPath(path2) {
-  const home = homedir7();
+  const home = homedir8();
   if (path2.startsWith(home))
     return `~${path2.slice(home.length)}`;
   return path2;
@@ -50510,7 +50644,7 @@ function registerFsTools(pi, ctx, surface) {
 
 // src/tools/hoisted.ts
 import { stat } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir9 } from "node:os";
 import { isAbsolute, relative as relative3, resolve as resolve3 } from "node:path";
 import {
   renderDiff as renderDiff2
@@ -50707,7 +50841,7 @@ function registerHoistedTools(pi, ctx, surface) {
       promptGuidelines: ["Use write only for new files or complete rewrites."],
       parameters: WriteParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
-        await assertExternalDirectoryPermission(extCtx, params.filePath);
+        await assertExternalDirectoryPermission(extCtx, params.filePath, "modify");
         const bridge = bridgeFor(ctx, extCtx.cwd);
         const response = await callBridge(bridge, "write", {
           file: params.filePath,
@@ -50738,7 +50872,7 @@ function registerHoistedTools(pi, ctx, surface) {
       ],
       parameters: EditParams,
       async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
-        await assertExternalDirectoryPermission(extCtx, params.filePath);
+        await assertExternalDirectoryPermission(extCtx, params.filePath, "modify");
         const bridge = bridgeFor(ctx, extCtx.cwd);
         if (typeof params.appendContent === "string") {
           const req2 = {
@@ -50808,6 +50942,7 @@ function buildMutationResult(filePath, response) {
   const replacements = response.replacements;
   const diagnostics = response.lsp_diagnostics;
   const truncated = diffObj?.truncated === true;
+  const noOp = response.no_op === true;
   const formatted = response.formatted;
   const formatSkippedReason = response.format_skipped_reason;
   const globFormatSkipReasons = response.format_skip_reasons;
@@ -50828,6 +50963,11 @@ ${diffText}`;
     text += `
 
 (diff truncated — file too large to include before/after content)`;
+  }
+  if (noOp) {
+    text += `
+
+Note: no net file change — the match was found and applied, but the file content is byte-identical to before. Likely causes: oldString and newString are identical, or a formatter normalized the change away.`;
   }
   const skipNote = formatSkipReasonNote(formatSkippedReason);
   if (skipNote)
@@ -50856,7 +50996,8 @@ ${formatDiagnosticsText(diagnostics)}`;
       diagnostics,
       truncated: truncated || undefined,
       formatted,
-      formatSkippedReason
+      formatSkippedReason,
+      noOp: noOp || undefined
     }
   };
 }
@@ -50927,7 +51068,12 @@ ${theme.fg("error", errorText || "edit failed")}`);
     const deletions = details?.deletions ?? 0;
     const text = reuseText3(context.lastComponent);
     const summary = theme.fg("success", `+${additions}/-${deletions}`);
-    const suffix = details?.truncated ? ` ${theme.fg("muted", "(diff truncated)")}` : "";
+    let suffix = "";
+    if (details?.truncated) {
+      suffix = ` ${theme.fg("muted", "(diff truncated)")}`;
+    } else if (details?.noOp) {
+      suffix = ` ${theme.fg("muted", "(no net change)")}`;
+    }
     text.setText(`
 ${summary}${suffix}`);
     return text;
@@ -50939,7 +51085,7 @@ ${summary}${suffix}`);
   return container;
 }
 function shortenPath2(path2) {
-  const home = homedir8();
+  const home = homedir9();
   if (path2.startsWith(home))
     return `~${path2.slice(home.length)}`;
   return path2;
@@ -50978,9 +51124,9 @@ function splitIncludeGlobs(include) {
     }
     buf += ch;
   }
-  const tail = buf.trim();
-  if (tail.length > 0)
-    out.push(tail);
+  const tail2 = buf.trim();
+  if (tail2.length > 0)
+    out.push(tail2);
   return out;
 }
 function formatReadFooter(agentSpecifiedRange, data) {
@@ -52201,15 +52347,12 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.18.0";
+var ANNOUNCEMENT_VERSION = "0.27.0";
 var ANNOUNCEMENT_FEATURES = [
-  `New experimental features — AFT now optionally hoists bash:
-    - Run bash scripts in the background.
-    - Initial output compression for git, cargo, npm, bun, pnpm, pytest, tsc (more in 0.19).
-    - Rewrite cat/grep/find/sed/ls into AFT counterparts for faster, formatted output.
-  Check GitHub for how to enable.`,
-  "Trigram grep/glob and semantic search (aft_search) graduated out of experimental.",
-  "Lots of bugfixes and new end-to-end test coverage."
+  "Storage moved to ~/.local/share/cortexkit/aft (~/Library/Application Support/cortexkit/aft on macOS, %APPDATA%/cortexkit/aft on Windows). Your existing data migrated automatically on first launch.",
+  "Bash output compression now reports token savings — visible in /aft-status (Session + Project totals).",
+  "Seven new languages supported by aft_outline / aft_zoom / aft_search / ast_grep: Java, Ruby, Kotlin, Swift, PHP, Lua, Perl.",
+  "Join us on Discord: https://discord.gg/F2uWxjGnU"
 ];
 var ALL_ONLY_TOOLS = new Set([
   "aft_navigate",
@@ -52259,14 +52402,12 @@ async function handleConfigureWarningsForSession(context) {
   await deliverConfigureWarnings({
     client: context.client,
     sessionId: context.sessionId,
+    bridge: context.bridge,
     storageDir: context.storageDir,
     pluginVersion: context.pluginVersion,
     projectRoot: context.projectRoot
   }, combinedWarnings);
 }
-function resolveStorageDir() {
-  return join13(homedir9(), ".pi", "agent", "aft");
-}
 function resolveToolSurface(config2) {
   const surface = config2.tool_surface ?? "recommended";
   const disabled = new Set(config2.disabled_tools ?? []);
@@ -52337,8 +52478,9 @@ async function src_default(pi) {
     warn2(`Failed to resolve AFT binary: ${err instanceof Error ? err.message : String(err)}. ` + "Tools will not be registered.");
     return;
   }
+  await ensureStorageMigrated({ harness: "pi", binaryPath, logger: bridgeLogger });
   const config2 = loadAftConfig(process.cwd());
-  const storageDir = resolveStorageDir();
+  const storageDir = resolveCortexKitStorageRoot();
   let onnxRuntimePromise = null;
   if (shouldPrepareOnnxRuntime(config2)) {
     onnxRuntimePromise = ensureOnnxRuntime(storageDir).catch((err) => {
@@ -52439,16 +52581,22 @@ ${lines}
     errorPrefix: "[aft-pi]",
     minVersion: PLUGIN_VERSION,
     onVersionMismatch: createVersionMismatchHandler(() => pool),
-    onConfigureWarnings: async ({ projectRoot, sessionId, client, warnings }) => {
+    onConfigureWarnings: ({ projectRoot, sessionId, client, warnings }) => {
+      const bridge = pool.getActiveBridgeForRoot(projectRoot);
+      if (!bridge)
+        return;
       const pendingWarnings = sessionId ? drainPendingEagerWarnings(projectRoot) : [];
-      await handleConfigureWarningsForSession({
-        projectRoot,
-        sessionId,
-        client,
-        warnings: [...pendingWarnings, ...warnings],
-        storageDir,
-        pluginVersion: PLUGIN_VERSION
-      });
+      setTimeout(() => {
+        handleConfigureWarningsForSession({
+          projectRoot,
+          sessionId,
+          client,
+          bridge,
+          warnings: [...pendingWarnings, ...warnings],
+          storageDir,
+          pluginVersion: PLUGIN_VERSION
+        });
+      }, 0);
     },
     onBashCompletion: (completion) => {
       handlePushedBgCompletion({
@@ -52468,6 +52616,7 @@ ${lines}
     }
   };
   pool = new BridgePool(binaryPath, poolOptions, configOverrides);
+  pool.setConfigureOverride("harness", "pi");
   const ctx = { pool, config: config2, storageDir };
   if (onnxRuntimePromise) {
     onnxRuntimePromise.then((ortDylibDir) => {