@cortexkit/aft-pi 0.21.0 → 0.22.1

package/dist/index.js

@@ -18761,7 +18761,7 @@ var require_fetch = __commonJS((exports, module) => {
       request.cache = "no-store";
     }
     const newConnection = forceNewConnection ? "yes" : "no";
-    if (request.mode === "websocket") {} else {}
+    if (request.mode === "websocket") {}
     let requestBody = null;
     if (request.body == null && fetchParams.processRequestEndOfBody) {
       queueMicrotask(() => fetchParams.processRequestEndOfBody());
@@ -30476,17 +30476,24 @@ 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 join12 } from "node:path";
+import { join as join13 } from "node:path";
 
 // ../aft-bridge/dist/active-logger.js
-var active;
+var ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
+function loggerGlobal() {
+  return globalThis;
+}
 function setActiveLogger(logger) {
-  active = logger;
+  loggerGlobal()[ACTIVE_LOGGER_SYMBOL] = logger;
+}
+function getActiveLogger() {
+  return loggerGlobal()[ACTIVE_LOGGER_SYMBOL];
 }
 function getLogFilePath() {
-  return active?.getLogFilePath?.();
+  return getActiveLogger()?.getLogFilePath?.();
 }
 function log(message, meta) {
+  const active = getActiveLogger();
   if (active) {
     active.log(message, meta);
   } else {
@@ -30494,6 +30501,7 @@ function log(message, meta) {
   }
 }
 function warn(message, meta) {
+  const active = getActiveLogger();
   if (active) {
     active.warn(message, meta);
   } else {
@@ -30501,6 +30509,7 @@ function warn(message, meta) {
   }
 }
 function error(message, meta) {
+  const active = getActiveLogger();
   if (active) {
     active.error(message, meta);
   } else {
@@ -30520,6 +30529,7 @@ function sessionError(sessionId, message) {
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
 var DEFAULT_BRIDGE_TIMEOUT_MS = 30000;
 var SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS = 5000;
 var MAX_STDOUT_BUFFER = 64 * 1024 * 1024;
@@ -30616,6 +30626,7 @@ class BinaryBridge {
   configureWarningClients = new Map;
   restartResetTimer = null;
   errorPrefix;
+  logger;
   constructor(binaryPath, cwd, options, configOverrides) {
     this.binaryPath = binaryPath;
     this.cwd = cwd;
@@ -30628,6 +30639,28 @@ class BinaryBridge {
     this.onBashCompletion = options?.onBashCompletion;
     this.onBashLongRunning = options?.onBashLongRunning;
     this.errorPrefix = options?.errorPrefix ?? "[aft-bridge]";
+    this.logger = options?.logger;
+  }
+  logVia(message, meta) {
+    const logger = this.logger ?? getActiveLogger();
+    if (logger)
+      logger.log(message, meta);
+    else
+      log(message, meta);
+  }
+  warnVia(message, meta) {
+    const logger = this.logger ?? getActiveLogger();
+    if (logger)
+      logger.warn(message, meta);
+    else
+      warn(message, meta);
+  }
+  errorVia(message, meta) {
+    const logger = this.logger ?? getActiveLogger();
+    if (logger)
+      logger.error(message, meta);
+    else
+      error(message, meta);
   }
   get restartCount() {
     return this._restartCount;
@@ -30736,8 +30769,8 @@ class BinaryBridge {
       return;
     if (configResult.warnings.length === 0)
       return;
+    const sessionId = typeof params.session_id === "string" ? params.session_id : undefined;
     try {
-      const sessionId = typeof params.session_id === "string" ? params.session_id : undefined;
       await this.onConfigureWarnings({
         projectRoot: this.cwd,
         sessionId,
@@ -30746,6 +30779,10 @@ class BinaryBridge {
       });
     } catch (err) {
       warn(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      if (sessionId) {
+        this.configureWarningClients.delete(sessionId);
+      }
     }
   }
   async handleConfigureWarningsFrame(frame) {
@@ -30757,16 +30794,23 @@ class BinaryBridge {
     const projectRoot = typeof frame.project_root === "string" ? frame.project_root : this.cwd;
     const rawSessionId = frame.session_id;
     const sessionId = typeof rawSessionId === "string" && rawSessionId.length > 0 ? rawSessionId : null;
-    await this.onConfigureWarnings({
-      projectRoot,
-      sessionId,
-      client: sessionId ? this.configureWarningClients.get(sessionId) : undefined,
-      warnings
-    });
+    try {
+      await this.onConfigureWarnings({
+        projectRoot,
+        sessionId,
+        client: sessionId ? this.configureWarningClients.get(sessionId) : undefined,
+        warnings
+      });
+    } finally {
+      if (sessionId) {
+        this.configureWarningClients.delete(sessionId);
+      }
+    }
   }
   async shutdown() {
     this._shuttingDown = true;
     this.clearRestartResetTimer();
+    this.configureWarningClients.clear();
     this.rejectAllPending(new Error(`${this.errorPrefix} Bridge shutting down`));
     if (this.process) {
       const proc = this.process;
@@ -30790,10 +30834,12 @@ class BinaryBridge {
       return;
     try {
       const resp = await this.send("version");
+      if (resp.success === false) {
+        throw new Error(`Binary version check failed: ${String(resp.code ?? "unknown")} — likely too old`);
+      }
       const binaryVersion = resp.version;
-      if (!binaryVersion) {
-        log("Binary did not report a version — skipping version check");
-        return;
+      if (typeof binaryVersion !== "string") {
+        throw new Error(`Binary did not report a version — likely too old (minVersion: ${this.minVersion})`);
       }
       log(`Binary version: ${binaryVersion}`);
       if (compareSemver(binaryVersion, this.minVersion) < 0) {
@@ -30802,6 +30848,7 @@ class BinaryBridge {
       }
     } catch (err) {
       warn(`Version check failed: ${err.message}`);
+      throw err;
     }
   }
   ensureSpawned(triggeringSessionId) {
@@ -30843,19 +30890,23 @@ class BinaryBridge {
       env
     });
     const currentChild = child;
+    const stdoutDecoder = new StringDecoder("utf8");
     child.stdout?.on("data", (chunk) => {
-      this.onStdoutData(chunk.toString("utf-8"));
+      this.onStdoutData(stdoutDecoder.write(chunk));
+    });
+    child.stdout?.on("end", () => {
+      const remaining = stdoutDecoder.end();
+      if (remaining)
+        this.onStdoutData(remaining);
     });
+    const stderrDecoder = new StringDecoder("utf8");
     child.stderr?.on("data", (chunk) => {
-      const lines = chunk.toString("utf-8").trimEnd().split(`
-`);
-      for (const line of lines) {
-        if (!line)
-          continue;
-        const tagged = tagStderrLine(line);
-        log(tagged);
-        this.pushStderrLine(tagged);
-      }
+      this.onStderrData(stderrDecoder.write(chunk));
+    });
+    child.stderr?.on("end", () => {
+      const remaining = stderrDecoder.end();
+      if (remaining)
+        this.onStderrData(remaining);
     });
     child.on("error", (err) => {
       if (this.process !== currentChild)
@@ -30888,6 +30939,17 @@ class BinaryBridge {
       this.stderrTail.shift();
     }
   }
+  onStderrData(data) {
+    const lines = data.trimEnd().split(`
+`);
+    for (const line of lines) {
+      if (!line)
+        continue;
+      const tagged = tagStderrLine(line);
+      log(tagged);
+      this.pushStderrLine(tagged);
+    }
+  }
   formatStderrTail() {
     if (this.stderrTail.length === 0)
       return "";
@@ -30967,6 +31029,7 @@ class BinaryBridge {
     }
   }
   handleTimeout(triggeringSessionId) {
+    this.rejectAllPending(new Error(`${this.errorPrefix} bridge killed during sibling timeout — request aborted`));
     if (this.process) {
       this.process.kill("SIGKILL");
       this.process = null;
@@ -31292,23 +31355,23 @@ async function ensureOnnxRuntime(storageDir) {
   const onnxBaseDir = join3(storageDir, "onnxruntime");
   mkdirSync2(onnxBaseDir, { recursive: true });
   const lockPath = join3(onnxBaseDir, ONNX_LOCK_FILE);
-  cleanupAbandonedOnnxAttempts(onnxBaseDir, ortDir);
+  cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
     return null;
   }
   try {
+    cleanupIncompleteTargetIfUnowned(ortDir);
     return await downloadOnnxRuntime(info, ortDir);
   } finally {
     releaseLock(lockPath);
   }
 }
-function cleanupAbandonedOnnxAttempts(onnxBaseDir, ortDir) {
+function cleanupAbandonedStagingDirs(onnxBaseDir) {
   try {
     const entries = readdirSync(onnxBaseDir);
-    const ortDirBaseName = ortDir.slice(onnxBaseDir.length + 1);
     for (const entry of entries) {
-      if (!entry.startsWith(`${ortDirBaseName}.tmp.`))
+      if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
       const stagingDir = join3(onnxBaseDir, entry);
       const parts = entry.split(".");
@@ -31339,6 +31402,8 @@ function cleanupAbandonedOnnxAttempts(onnxBaseDir, ortDir) {
       }
     }
   } catch {}
+}
+function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
     if (existsSync2(ortDir) && !existsSync2(join3(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
@@ -31529,25 +31594,7 @@ async function downloadOnnxRuntime(info, targetDir) {
         realFiles.push(libFile);
       }
     }
-    for (const libFile of realFiles) {
-      const src = join3(extractedDir, libFile);
-      const dst = join3(targetDir, libFile);
-      try {
-        copyFileSync(src, dst);
-        if (process.platform !== "win32") {
-          chmodSync2(dst, 493);
-        }
-      } catch (copyErr) {
-        log(`ORT extract: failed to copy ${libFile}: ${copyErr}`);
-      }
-    }
-    for (const link of symlinks) {
-      const dst = join3(targetDir, link.name);
-      try {
-        unlinkSync2(dst);
-      } catch {}
-      symlinkSync(link.target, dst);
-    }
+    copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
     const libPath = join3(targetDir, info.libName);
     let libHash = null;
     try {
@@ -31570,6 +31617,45 @@ async function downloadOnnxRuntime(info, targetDir) {
     return null;
   }
 }
+function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync) {
+  const requiredLibs = new Set([info.libName]);
+  for (const libFile of realFiles) {
+    const src = join3(extractedDir, libFile);
+    const dst = join3(targetDir, libFile);
+    try {
+      copyFile(src, dst);
+      if (process.platform !== "win32") {
+        chmodSync2(dst, 493);
+      }
+    } catch (copyErr) {
+      if (requiredLibs.has(libFile)) {
+        rmSync(targetDir, { recursive: true, force: true });
+        throw copyErr;
+      }
+      log(`ORT extract: failed to copy optional ${libFile}: ${copyErr}`);
+    }
+  }
+  for (const link of symlinks) {
+    const dst = join3(targetDir, link.name);
+    try {
+      unlinkSync2(dst);
+    } catch {}
+    try {
+      symlinkSync(link.target, dst);
+    } catch (symlinkErr) {
+      if (requiredLibs.has(link.name)) {
+        rmSync(targetDir, { recursive: true, force: true });
+        throw symlinkErr;
+      }
+      log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
+    }
+  }
+  const requiredPath = join3(targetDir, info.libName);
+  if (!existsSync2(requiredPath)) {
+    rmSync(targetDir, { recursive: true, force: true });
+    throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
+  }
+}
 async function extractZipArchive(archivePath, destinationDir) {
   if (process.platform === "win32") {
     execFileSync("tar.exe", ["-xf", archivePath, "-C", destinationDir], {
@@ -31753,11 +31839,13 @@ class BridgePool {
   idleTimeoutMs;
   bridgeOptions;
   configOverrides;
+  logger;
   cleanupTimer = null;
   constructor(binaryPath, options = {}, configOverrides = {}) {
     this.binaryPath = binaryPath;
     this.maxPoolSize = options.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE;
     this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    this.logger = options.logger;
     this.bridgeOptions = {
       timeoutMs: options.timeoutMs,
       maxRestarts: options.maxRestarts,
@@ -31801,8 +31889,10 @@ class BridgePool {
   cleanup() {
     const now = Date.now();
     for (const [dir, entry] of this.bridges) {
+      if (entry.bridge.hasPendingRequests())
+        continue;
       if (now - entry.lastUsed > this.idleTimeoutMs) {
-        entry.bridge.shutdown().catch((err) => error("cleanup shutdown failed:", err));
+        entry.bridge.shutdown().catch((err) => this.error("cleanup shutdown failed:", err));
         this.bridges.delete(dir);
       }
     }
@@ -31811,6 +31901,8 @@ class BridgePool {
     let oldestDir = null;
     let oldestTime = Infinity;
     for (const [dir, entry] of this.bridges) {
+      if (entry.bridge.hasPendingRequests())
+        continue;
       if (entry.lastUsed < oldestTime) {
         oldestTime = entry.lastUsed;
         oldestDir = dir;
@@ -31818,7 +31910,7 @@ class BridgePool {
     }
     if (oldestDir) {
       const entry = this.bridges.get(oldestDir);
-      entry?.bridge.shutdown().catch((err) => error("eviction shutdown failed:", err));
+      entry?.bridge.shutdown().catch((err) => this.error("eviction shutdown failed:", err));
       this.bridges.delete(oldestDir);
     }
   }
@@ -31836,7 +31928,21 @@ class BridgePool {
     const shutdowns = Array.from(this.bridges.values()).map((entry) => entry.bridge.shutdown());
     this.bridges.clear();
     await Promise.allSettled(shutdowns);
-    log(`Binary path updated to ${newPath}. All bridges cleared — next calls will use the new binary.`);
+    this.log(`Binary path updated to ${newPath}. All bridges cleared — next calls will use the new binary.`);
+  }
+  log(message, meta) {
+    const logger = this.logger ?? getActiveLogger();
+    if (logger)
+      logger.log(message, meta);
+    else
+      log(message, meta);
+  }
+  error(message, meta) {
+    const logger = this.logger ?? getActiveLogger();
+    if (logger)
+      logger.error(message, meta);
+    else
+      error(message, meta);
   }
   setConfigureOverride(key, value) {
     if (value === undefined) {
@@ -31956,7 +32062,7 @@ async function findBinary(expectedVersion) {
     return syncResult;
   }
   log("Binary not found locally, attempting auto-download...");
-  const downloaded = await ensureBinary();
+  const downloaded = await ensureBinary(expectedVersion);
   if (downloaded)
     return downloaded;
   throw new Error([
@@ -32630,8 +32736,6 @@ async function handleTurnEndBgCompletions(drainContext) {
 }
 async function triggerWakeIfPending(drainContext, skipDrain) {
   const state = stateFor(drainContext.sessionID);
-  if (state.wakeFiredThisIdle)
-    return;
   if (drainContext.isActive?.())
     return;
   if (!skipDrain && state.outstandingTaskIds.size > 0) {
@@ -32645,9 +32749,6 @@ async function triggerWakeIfPending(drainContext, skipDrain) {
     sessionWarn2(drainContext.sessionID ?? "", `${LOG_PREFIX} wake send failed: ${err instanceof Error ? err.message : String(err)}`);
   });
 }
-function resetBgWake(sessionID) {
-  stateFor(sessionID).wakeFiredThisIdle = false;
-}
 function formatSystemReminder(completions) {
   const bullets = completions.map((completion) => formatCompletion(completion)).join(`
 `);
@@ -32723,7 +32824,6 @@ function scheduleWake(state, sendWake, onSendFailure) {
     state.pendingLongRunning = [];
     sendWake(reminder).then(() => {
       state.retryDelayMs = null;
-      state.wakeFiredThisIdle = true;
     }).catch((err) => {
       state.pendingCompletions = [...pending, ...state.pendingCompletions];
       state.pendingLongRunning = [...pendingLongRunning, ...state.pendingLongRunning];
@@ -32745,7 +32845,6 @@ function stateFor(sessionID) {
       pendingCompletions: [],
       pendingLongRunning: [],
       debounceTimer: null,
-      wakeFiredThisIdle: false,
       firstCompletionAt: null,
       scheduledFireAt: null,
       scheduledCompletionCount: 0,
@@ -43998,7 +44097,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -44246,7 +44345,7 @@ var literalProcessor = (schema, ctx, json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -47046,7 +47145,8 @@ function loadAftConfig(projectDirectory) {
 // src/lsp-auto-install.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import { createReadStream, statSync as statSync3 } from "node:fs";
+import { createReadStream, mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync3, rmSync as rmSync2, statSync as statSync3 } from "node:fs";
+import { join as join10 } from "node:path";
 
 // src/lsp-cache.ts
 import {
@@ -47730,6 +47830,50 @@ function hashInstalledBinary(spec) {
     stream.on("end", () => resolve2(hash2.digest("hex")));
   });
 }
+function installedBinaryPath(spec) {
+  const candidates = process.platform === "win32" ? [
+    lspBinaryPath(spec.npm, spec.binary),
+    lspBinaryPath(spec.npm, `${spec.binary}.cmd`),
+    lspBinaryPath(spec.npm, `${spec.binary}.exe`),
+    lspBinaryPath(spec.npm, `${spec.binary}.bat`)
+  ] : [lspBinaryPath(spec.npm, spec.binary)];
+  for (const candidate of candidates) {
+    try {
+      if (statSync3(candidate).isFile())
+        return candidate;
+    } catch {}
+  }
+  return null;
+}
+function sha256OfFileSync(path2) {
+  return createHash3("sha256").update(readFileSync5(path2)).digest("hex");
+}
+function quarantineCachedNpmInstall(spec, reason) {
+  const packageDir = lspPackageDir(spec.npm);
+  const dest = join10(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
+  try {
+    mkdirSync6(join10(dest, ".."), { recursive: true });
+    rmSync2(dest, { recursive: true, force: true });
+    renameSync3(packageDir, dest);
+  } catch (err) {
+    warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
+  }
+}
+function validateCachedNpmInstall(spec) {
+  const meta3 = readInstalledMeta(spec.npm);
+  const binaryPath = installedBinaryPath(spec);
+  if (!meta3?.sha256 || !meta3.version || !isSafeVersion(meta3.version) || !binaryPath) {
+    quarantineCachedNpmInstall(spec, "missing/unsafe metadata or binary");
+    return false;
+  }
+  const currentHash = sha256OfFileSync(binaryPath);
+  if (currentHash !== meta3.sha256) {
+    quarantineCachedNpmInstall(spec, `recorded ${meta3.sha256}, current ${currentHash}`);
+    return false;
+  }
+  return true;
+}
 function runAutoInstall(projectRoot, config2, fetchImpl2 = fetch) {
   const cachedBinDirs = [];
   const skipped = [];
@@ -47742,7 +47886,7 @@ function runAutoInstall(projectRoot, config2, fetchImpl2 = fetch) {
     return projectExtensions;
   };
   for (const spec of NPM_LSP_TABLE) {
-    if (isInstalled(spec.npm, spec.binary)) {
+    if (isInstalled(spec.npm, spec.binary) && validateCachedNpmInstall(spec)) {
       cachedBinDirs.push(lspBinDir(spec.npm));
     }
     if (config2.disabled.has(spec.id)) {
@@ -47794,16 +47938,17 @@ import {
   createWriteStream as createWriteStream2,
   existsSync as existsSync7,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   readdirSync as readdirSync4,
+  readFileSync as readFileSync6,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync3,
-  rmSync as rmSync2,
+  renameSync as renameSync4,
+  rmSync as rmSync3,
   statSync as statSync4,
   unlinkSync as unlinkSync6
 } from "node:fs";
-import { dirname as dirname2, join as join10, relative as relative2, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, join as join11, relative as relative2, resolve as resolve2 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 
@@ -47893,25 +48038,25 @@ function detectHostPlatform() {
 
 // src/lsp-github-install.ts
 function ghCacheRoot() {
-  return join10(aftCacheBase(), "lsp-binaries");
+  return join11(aftCacheBase(), "lsp-binaries");
 }
 function ghPackageDir(spec) {
-  return join10(ghCacheRoot(), spec.id);
+  return join11(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join10(ghPackageDir(spec), "bin");
+  return join11(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join10(ghPackageDir(spec), "extracted");
+  return join11(ghPackageDir(spec), "extracted");
 }
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return join10(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join11(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync4(join10(ghBinDir(spec), candidate)).isFile())
+      if (statSync4(join11(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -47933,6 +48078,9 @@ function sha256OfFile(path2) {
     stream.on("end", () => resolve3(hash2.digest("hex")));
   });
 }
+function sha256OfFileSync2(path2) {
+  return createHash4("sha256").update(readFileSync6(path2)).digest("hex");
+}
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl2, signal) {
   const candidates = [];
   candidates.push(tag);
@@ -47953,11 +48101,7 @@ async function fetchReleaseByTag(githubRepo, tag, fetchImpl2, signal) {
     const url2 = `https://api.github.com/repos/${githubRepo}/releases/tags/${encodeURIComponent(candidate)}`;
     const timeout = controlledTimeoutSignal(15000, signal);
     try {
-      const res = await fetchImpl2(url2, {
-        headers,
-        redirect: "follow",
-        signal: timeout.signal
-      });
+      const res = await fetchJsonFollowingRedirects(url2, headers, fetchImpl2, timeout.signal);
       if (res.status === 404)
         continue;
       if (!res.ok) {
@@ -47987,6 +48131,23 @@ async function fetchReleaseByTag(githubRepo, tag, fetchImpl2, signal) {
   }
   return null;
 }
+async function fetchJsonFollowingRedirects(url2, headers, fetchImpl2, signal) {
+  const maxRedirects = 5;
+  let currentUrl = url2;
+  for (let i = 0;i <= maxRedirects; i += 1) {
+    assertAllowedDownloadUrl(currentUrl);
+    const res = await fetchImpl2(currentUrl, { headers, redirect: "manual", signal });
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (!location)
+        throw new Error(`redirect status ${res.status} without Location`);
+      currentUrl = new URL(location, currentUrl).toString();
+      continue;
+    }
+    return res;
+  }
+  throw new Error(`too many redirects (>${maxRedirects})`);
+}
 async function resolveTargetTag(spec, config2, fetchImpl2, signal) {
   const pinned = config2.versions[spec.githubRepo];
   if (pinned) {
@@ -48081,17 +48242,12 @@ function assertAllowedDownloadUrl(rawUrl) {
   return parsed;
 }
 async function downloadFile(url2, destPath, fetchImpl2, assetSize, signal) {
-  assertAllowedDownloadUrl(url2);
   if (assetSize !== undefined && assetSize > MAX_DOWNLOAD_BYTES2) {
     throw new Error(`asset size ${assetSize} exceeds max ${MAX_DOWNLOAD_BYTES2} (set lsp.versions to pin a smaller release if this is wrong)`);
   }
   const timeout = controlledTimeoutSignal(120000, signal);
   try {
-    const res = await fetchImpl2(url2, {
-      headers: { accept: "application/octet-stream" },
-      redirect: "follow",
-      signal: timeout.signal
-    });
+    const res = await fetchFollowingRedirects(url2, fetchImpl2, timeout.signal);
     if (!res.ok || !res.body) {
       throw new Error(`download failed (${res.status})`);
     }
@@ -48099,7 +48255,7 @@ async function downloadFile(url2, destPath, fetchImpl2, assetSize, signal) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
     }
-    mkdirSync6(dirname2(destPath), { recursive: true });
+    mkdirSync7(dirname2(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -48123,6 +48279,27 @@ async function downloadFile(url2, destPath, fetchImpl2, assetSize, signal) {
     timeout.cleanup();
   }
 }
+async function fetchFollowingRedirects(url2, fetchImpl2, signal) {
+  const maxRedirects = 5;
+  let currentUrl = url2;
+  for (let i = 0;i <= maxRedirects; i += 1) {
+    assertAllowedDownloadUrl(currentUrl);
+    const res = await fetchImpl2(currentUrl, {
+      headers: { accept: "application/octet-stream" },
+      redirect: "manual",
+      signal
+    });
+    if (res.status >= 300 && res.status < 400) {
+      const location = res.headers.get("location");
+      if (!location)
+        throw new Error(`redirect status ${res.status} without Location`);
+      currentUrl = new URL(location, currentUrl).toString();
+      continue;
+    }
+    return res;
+  }
+  throw new Error(`too many redirects (>${maxRedirects})`);
+}
 function validateExtraction(stagingRoot) {
   const realStagingRoot = realpathSync3(stagingRoot);
   let totalBytes = 0;
@@ -48134,7 +48311,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join10(dir, entry);
+      const full = join11(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -48172,27 +48349,83 @@ function validateExtraction(stagingRoot) {
   };
   walk(realStagingRoot);
 }
+function precheckArchiveSize(archivePath, archiveType) {
+  let totalBytes = 0;
+  if (archiveType === "zip") {
+    const out = execFileSync2("unzip", ["-l", archivePath], { encoding: "utf8" });
+    const match = out.match(/^\s*(\d+)\s+\d+\s+files?\s*$/m);
+    if (match)
+      totalBytes = Number.parseInt(match[1] ?? "0", 10);
+  } else {
+    const out = execFileSync2("tar", ["-tvf", archivePath], { encoding: "utf8" });
+    for (const line of out.split(`
+`)) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length >= 6) {
+        const numeric = parts.map((part) => Number.parseInt(part, 10)).filter((value) => Number.isFinite(value) && value >= 0);
+        if (numeric.length > 0)
+          totalBytes += Math.max(...numeric);
+      }
+    }
+  }
+  if (totalBytes > MAX_EXTRACT_BYTES2) {
+    throw new Error(`archive uncompressed size ${totalBytes} exceeds ${MAX_EXTRACT_BYTES2}`);
+  }
+}
 function extractArchiveSafely(archivePath, destDir, archiveType) {
   const suffix = randomBytes(8).toString("hex");
   const stagingDir = `${destDir}.staging-${suffix}`;
   try {
-    rmSync2(stagingDir, { recursive: true, force: true });
+    rmSync3(stagingDir, { recursive: true, force: true });
   } catch {}
-  mkdirSync6(stagingDir, { recursive: true });
+  mkdirSync7(stagingDir, { recursive: true });
   try {
+    precheckArchiveSize(archivePath, archiveType);
     runPlatformExtractor(archivePath, stagingDir, archiveType);
     validateExtraction(stagingDir);
     try {
-      rmSync2(destDir, { recursive: true, force: true });
+      rmSync3(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync3(stagingDir, destDir);
+    renameSync4(stagingDir, destDir);
   } catch (err) {
     try {
-      rmSync2(stagingDir, { recursive: true, force: true });
+      rmSync3(stagingDir, { recursive: true, force: true });
     } catch {}
     throw err;
   }
 }
+function quarantineCachedGithubInstall(spec, reason) {
+  const packageDir = ghPackageDir(spec);
+  const dest = join11(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
+  try {
+    mkdirSync7(dirname2(dest), { recursive: true });
+    rmSync3(dest, { recursive: true, force: true });
+    renameSync4(packageDir, dest);
+  } catch (err) {
+    warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
+  }
+}
+function validateCachedGithubInstall(spec, platform) {
+  const meta3 = readInstalledMetaIn(ghPackageDir(spec));
+  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join11(ghBinDir(spec), candidate)).find((candidate) => {
+    try {
+      return statSync4(candidate).isFile();
+    } catch {
+      return false;
+    }
+  });
+  if (!meta3?.sha256 || !meta3.version || !isSafeVersion(meta3.version) || !binaryPath) {
+    quarantineCachedGithubInstall(spec, "missing/unsafe metadata or binary");
+    return false;
+  }
+  const currentHash = sha256OfFileSync2(binaryPath);
+  if (currentHash !== meta3.sha256) {
+    quarantineCachedGithubInstall(spec, `recorded ${meta3.sha256}, current ${currentHash}`);
+    return false;
+  }
+  return true;
+}
 function runPlatformExtractor(archivePath, destDir, archiveType) {
   if (archiveType === "zip") {
     if (process.platform === "win32") {
@@ -48238,7 +48471,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join10(pkgDir, expected.name);
+  const archivePath = join11(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl2, matchingAsset.size, signal);
@@ -48277,13 +48510,13 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl2,
       unlinkSync6(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join10(extractDir, spec.binaryPathInArchive(platform, arch, version2));
+  const innerBinaryPath = join11(extractDir, spec.binaryPathInArchive(platform, arch, version2));
   if (!existsSync7(innerBinaryPath)) {
     error2(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
     return null;
   }
   const targetBinary = ghBinaryPath(spec, platform);
-  mkdirSync6(dirname2(targetBinary), { recursive: true });
+  mkdirSync7(dirname2(targetBinary), { recursive: true });
   try {
     copyFileSync3(innerBinaryPath, targetBinary);
     if (platform !== "win32") {
@@ -48374,7 +48607,7 @@ function runGithubAutoInstall(relevantServers, config2, fetchImpl2 = fetch) {
     };
   }
   for (const spec of GITHUB_LSP_TABLE) {
-    if (isGithubInstalled(spec, host.platform)) {
+    if (isGithubInstalled(spec, host.platform) && validateCachedGithubInstall(spec, host.platform)) {
       cachedBinDirs.push(ghBinDir(spec));
     }
     if (config2.disabled.has(spec.id)) {
@@ -48458,8 +48691,8 @@ function discoverRelevantGithubServers(projectRoot) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync7, renameSync as renameSync5, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join12 } from "node:path";
 var WARNING_MARKER = "\uD83D\uDD27 AFT: ⚠️";
 var FEATURE_MARKER = "\uD83D\uDD27 AFT: ✨";
 var WARNED_TOOLS_FILE = "warned_tools.json";
@@ -48477,10 +48710,10 @@ function sendIgnoredMessage(client, sessionId, text) {
 }
 function readWarnedTools(storageDir) {
   try {
-    const warnedToolsPath = join11(storageDir, WARNED_TOOLS_FILE);
+    const warnedToolsPath = join12(storageDir, WARNED_TOOLS_FILE);
     if (!existsSync8(warnedToolsPath))
       return {};
-    const parsed = JSON.parse(readFileSync5(warnedToolsPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync7(warnedToolsPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
     const warned = {};
@@ -48496,12 +48729,34 @@ function readWarnedTools(storageDir) {
 }
 function writeWarnedTools(storageDir, warned) {
   try {
-    mkdirSync7(storageDir, { recursive: true });
-    const warnedToolsPath = join11(storageDir, WARNED_TOOLS_FILE);
-    writeFileSync5(warnedToolsPath, `${JSON.stringify(warned, null, 2)}
+    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`);
+    writeFileSync5(tmpPath, `${JSON.stringify(warned, null, 2)}
 `);
+    renameSync5(tmpPath, warnedToolsPath);
   } 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 {
+        rmSync4(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 [
@@ -48540,27 +48795,36 @@ ${warning.hint}`;
 async function deliverConfigureWarnings(opts, warnings) {
   if (warnings.length === 0)
     return;
-  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;
+  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;
     }
-    warned[key] = opts.pluginVersion;
-    changed = true;
-  }
-  if (changed) {
-    writeWarnedTools(opts.storageDir, warned);
+    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));
   }
 }
 function sendFeatureAnnouncement(version2, features, storageDir) {
-  const versionFile = join11(storageDir, "last_announced_version");
+  const versionFile = join12(storageDir, "last_announced_version");
   try {
     if (existsSync8(versionFile)) {
-      const lastVersion = readFileSync5(versionFile, "utf-8").trim();
+      const lastVersion = readFileSync7(versionFile, "utf-8").trim();
       if (lastVersion === version2)
         return;
     }
@@ -48568,7 +48832,7 @@ function sendFeatureAnnouncement(version2, features, storageDir) {
   log2([`${FEATURE_MARKER} v${version2}:`, ...features.map((feature) => `  • ${feature}`)].join(`
 `));
   try {
-    mkdirSync7(storageDir, { recursive: true });
+    mkdirSync8(storageDir, { recursive: true });
     writeFileSync5(versionFile, version2);
   } catch {}
 }
@@ -50011,7 +50275,6 @@ var ImportParams = Type6.Object({
   defaultImport: Type6.Optional(Type6.String({ description: "Default import name (e.g. 'React')" })),
   removeName: Type6.Optional(Type6.String({ description: "Named import to remove; omit to remove entire import" })),
   typeOnly: Type6.Optional(Type6.Boolean({ description: "Type-only import (TS only)" })),
-  dryRun: Type6.Optional(Type6.Boolean({ description: "Preview without writing" })),
   validate: Type6.Optional(StringEnum2(["syntax", "full"], {
     description: "Post-edit validation level (default: syntax)"
   }))
@@ -50020,12 +50283,6 @@ function buildImportSections(args, payload, theme) {
   const response = asRecord2(payload);
   if (!response)
     return [theme.fg("muted", "No import result.")];
-  if (response.dry_run === true) {
-    return [
-      theme.fg("warning", `[dry run] ${args.op}`),
-      asString(response.diff) || theme.fg("muted", "No diff available.")
-    ];
-  }
   if (args.op === "organize") {
     const groups = asRecords(response.groups);
     const groupText = groups.length > 0 ? groups.map((group) => `${asString(group.name) ?? "unknown"}: ${asNumber(group.count) ?? 0}`).join(" · ") : "No imports found";
@@ -50068,7 +50325,7 @@ function registerImportTools(pi, ctx) {
   pi.registerTool({
     name: "aft_import",
     label: "import",
-    description: "Language-aware import management. Supports TS, JS, TSX, Python, Rust, Go. Ops: `add` (auto-groups stdlib/external/internal, deduplicates), `remove` (pass `removeName` for single name or omit to remove entire import), `organize` (re-sort + deduplicate).",
+    description: "Language-aware import management. Supports TS, JS, TSX, Python, Rust, Go. Ops: `add`, `remove`, `organize`. Use aft_safety checkpoint/undo before broad cleanup.",
     parameters: ImportParams,
     async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
       if ((params.op === "add" || params.op === "remove") && !params.module) {
@@ -50091,8 +50348,6 @@ function registerImportTools(pi, ctx) {
         req.name = params.removeName;
       if (params.typeOnly !== undefined)
         req.type_only = params.typeOnly;
-      if (params.dryRun !== undefined)
-        req.dry_run = params.dryRun;
       if (params.validate !== undefined)
         req.validate = params.validate;
       const response = await callBridge(bridge, commandMap[params.op], req, extCtx);
@@ -50573,7 +50828,7 @@ Pass a single \`target\`:
         if (response.success === false) {
           throw new Error(response.message || "zoom failed");
         }
-        return textResult(formatZoomText(targetLabel, response));
+        return textResult(formatZoomText(targetLabel, response), response);
       },
       renderCall(args, theme, context) {
         return renderZoomCall(args, theme, context);
@@ -50636,28 +50891,12 @@ var RefactorParams = Type10.Object({
   name: Type10.Optional(Type10.String({ description: "New function name (for extract)" })),
   startLine: Type10.Optional(Type10.Number({ description: "1-based start line (for extract)" })),
   endLine: Type10.Optional(Type10.Number({ description: "1-based end line, inclusive (for extract)" })),
-  callSiteLine: Type10.Optional(Type10.Number({ description: "1-based call site line (for inline)" })),
-  dryRun: Type10.Optional(Type10.Boolean({ description: "Preview as diff" }))
+  callSiteLine: Type10.Optional(Type10.Number({ description: "1-based call site line (for inline)" }))
 });
 function buildRefactorSections(args, payload, theme) {
   const response = asRecord2(payload);
   if (!response)
     return [theme.fg("muted", "No refactor result.")];
-  if (response.dry_run === true) {
-    const diffs = asRecords(response.diffs);
-    const sections = [theme.fg("warning", `[dry run] ${args.op}`)];
-    if (diffs.length === 0) {
-      sections.push(theme.fg("muted", "No diff available."));
-      return sections;
-    }
-    diffs.forEach((diff) => {
-      const file2 = shortenPath(asString(diff.file) ?? "(unknown file)");
-      const rendered = renderUnifiedDiff(asString(diff.diff) ?? "") || theme.fg("muted", "No diff available.");
-      sections.push(`${theme.fg("accent", file2)}
-${rendered}`);
-    });
-    return sections;
-  }
   if (args.op === "move") {
     const results = asRecords(response.results);
     return [
@@ -50700,7 +50939,7 @@ function registerRefactorTool(pi, ctx) {
   pi.registerTool({
     name: "aft_refactor",
     label: "refactor",
-    description: "Workspace-wide refactoring that updates imports and references across files. `move` relocates a top-level symbol (only top-level exports); `extract` pulls a line range into a new function; `inline` replaces a call site with the function body.",
+    description: "Workspace-wide refactoring that updates imports and references across files. `move` relocates a top-level symbol; `extract` pulls a line range into a new function; `inline` replaces a call site. Use aft_safety checkpoint/undo before risky refactors.",
     parameters: RefactorParams,
     async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
       const bridge = bridgeFor(ctx, extCtx.cwd);
@@ -50725,8 +50964,6 @@ function registerRefactorTool(pi, ctx) {
       }
       if (params.callSiteLine !== undefined)
         req.call_site_line = params.callSiteLine;
-      if (params.dryRun !== undefined)
-        req.dry_run = params.dryRun;
       const response = await callBridge(bridge, commandMap[params.op], req, extCtx);
       return textResult(JSON.stringify(response, null, 2));
     },
@@ -50985,7 +51222,6 @@ var TransformParams = Type13.Object({
   position: Type13.Optional(Type13.String({
     description: "Position hint: 'first', 'last' (default), 'before:name', 'after:name' for add_member"
   })),
-  dryRun: Type13.Optional(Type13.Boolean({ description: "Preview without modifying" })),
   validate: Type13.Optional(StringEnum7(["syntax", "full"], {
     description: "Validation level (default: syntax)"
   }))
@@ -50994,12 +51230,6 @@ function buildTransformSections(args, payload, theme) {
   const response = asRecord2(payload);
   if (!response)
     return [theme.fg("muted", "No transform result.")];
-  if (response.dry_run === true) {
-    return [
-      theme.fg("warning", `[dry run] ${args.op}`),
-      asString(response.diff) ?? theme.fg("muted", "No diff available.")
-    ];
-  }
   const target = asString(response.target) ?? asString(response.scope) ?? args.target ?? args.container ?? args.field ?? args.filePath;
   return [
     `${theme.fg("success", "transformed")} ${theme.fg("accent", args.op)}`,
@@ -51025,7 +51255,7 @@ function registerStructureTool(pi, ctx) {
   pi.registerTool({
     name: "aft_transform",
     label: "transform",
-    description: "Scope-aware structural code transformations with correct indentation. See parameter descriptions for per-op requirements.",
+    description: "Scope-aware structural code transformations with correct indentation. Use aft_safety checkpoint/undo before risky transforms.",
     parameters: TransformParams,
     async execute(_toolCallId, params, _signal, _onUpdate, extCtx) {
       validateTransformParams(params);
@@ -51051,8 +51281,6 @@ function registerStructureTool(pi, ctx) {
         req.value = params.value;
       if (params.position !== undefined)
         req.position = params.position;
-      if (params.dryRun !== undefined)
-        req.dry_run = params.dryRun;
       if (params.validate !== undefined)
         req.validate = params.validate;
       const response = await callBridge(bridge, params.op, req, extCtx);
@@ -51204,6 +51432,7 @@ var ALL_ONLY_TOOLS = new Set([
   "aft_transform",
   "aft_refactor"
 ]);
+var pendingEagerWarnings = new Map;
 function isConfigureWarning(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return false;
@@ -51213,17 +51442,33 @@ function isConfigureWarning(value) {
 function coerceConfigureWarnings(warnings) {
   return warnings.filter(isConfigureWarning);
 }
+function drainPendingEagerWarnings(projectRoot) {
+  const pending = pendingEagerWarnings.get(projectRoot) ?? [];
+  pendingEagerWarnings.delete(projectRoot);
+  return pending;
+}
+function shouldPrepareOnnxRuntime(config2) {
+  const isFastembedSemanticBackend = (config2.semantic?.backend ?? "fastembed") === "fastembed";
+  return config2.semantic_search === true && isFastembedSemanticBackend;
+}
 async function handleConfigureWarningsForSession(context) {
+  const validWarnings = coerceConfigureWarnings(context.warnings);
   if (!context.sessionId) {
-    warn2(`[configure] deferred warnings for ${context.projectRoot} arrived without session_id; skipping notification`);
+    if (validWarnings.length === 0)
+      return;
+    const pending = pendingEagerWarnings.get(context.projectRoot) ?? [];
+    pending.push(...validWarnings);
+    pendingEagerWarnings.set(context.projectRoot, pending);
+    warn2(`[configure] deferred warnings for ${context.projectRoot} arrived without session_id; buffering until first session-bound call`);
     return;
   }
   if (!context.client) {
     warn2(`[configure] deferred warnings for session ${context.sessionId} arrived without notification client; skipping notification`);
     return;
   }
-  const validWarnings = coerceConfigureWarnings(context.warnings);
-  if (validWarnings.length === 0)
+  const pendingWarnings = drainPendingEagerWarnings(context.projectRoot);
+  const combinedWarnings = [...pendingWarnings, ...validWarnings];
+  if (combinedWarnings.length === 0)
     return;
   await deliverConfigureWarnings({
     client: context.client,
@@ -51231,10 +51476,10 @@ async function handleConfigureWarningsForSession(context) {
     storageDir: context.storageDir,
     pluginVersion: context.pluginVersion,
     projectRoot: context.projectRoot
-  }, validWarnings);
+  }, combinedWarnings);
 }
 function resolveStorageDir() {
-  return join12(homedir9(), ".pi", "agent", "aft");
+  return join13(homedir9(), ".pi", "agent", "aft");
 }
 function resolveToolSurface(config2) {
   const surface = config2.tool_surface ?? "recommended";
@@ -51309,7 +51554,7 @@ async function src_default(pi) {
   const config2 = loadAftConfig(process.cwd());
   const storageDir = resolveStorageDir();
   let onnxRuntimePromise = null;
-  if (config2.semantic_search) {
+  if (shouldPrepareOnnxRuntime(config2)) {
     onnxRuntimePromise = ensureOnnxRuntime(storageDir).catch((err) => {
       warn2(`Failed to prepare ONNX Runtime: ${err instanceof Error ? err.message : String(err)}`);
       return null;
@@ -51407,11 +51652,12 @@ ${lines}
     errorPrefix: "[aft-pi]",
     minVersion: PLUGIN_VERSION,
     onConfigureWarnings: async ({ projectRoot, sessionId, client, warnings }) => {
+      const pendingWarnings = sessionId ? drainPendingEagerWarnings(projectRoot) : [];
       await handleConfigureWarningsForSession({
         projectRoot,
         sessionId,
         client,
-        warnings,
+        warnings: [...pendingWarnings, ...warnings],
         storageDir,
         pluginVersion: PLUGIN_VERSION
       });
@@ -51520,10 +51766,6 @@ ${lines}
       runtime: pi
     });
   });
-  pi.on("input", (_event, extCtx) => {
-    resetBgWake(resolveSessionId(extCtx));
-    return { action: "continue" };
-  });
   pi.on("session_shutdown", async () => {
     try {
       await Promise.allSettled([abortInFlightAutoInstalls(), abortInFlightGithubInstalls()]);
@@ -51543,7 +51785,11 @@ ${lines}
   });
   log2(`AFT extension ready (surface=${config2.tool_surface ?? "recommended"})`);
 }
-var __test__2 = { resolveToolSurface, handleConfigureWarningsForSession };
+var __test__2 = {
+  resolveToolSurface,
+  handleConfigureWarningsForSession,
+  shouldPrepareOnnxRuntime
+};
 export {
   src_default as default,
   __test__2 as __test__