@cortexkit/aft 0.35.0 → 0.35.1

package/dist/index.js

@@ -46,75 +46,1242 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
 
-// src/lib/paths.ts
-import { homedir, tmpdir } from "node:os";
+// ../aft-bridge/dist/active-logger.js
+function loggerGlobal() {
+  return globalThis;
+}
+function getActiveLogger() {
+  return loggerGlobal()[ACTIVE_LOGGER_SYMBOL];
+}
+function getLogFilePath() {
+  try {
+    return getActiveLogger()?.getLogFilePath?.();
+  } catch (err) {
+    console.error(`[aft-bridge] ERROR: active logger getLogFilePath threw: ${err instanceof Error ? err.message : String(err)}`);
+    return;
+  }
+}
+function log(message, meta) {
+  const active = getActiveLogger();
+  if (active) {
+    try {
+      active.log(message, meta);
+    } catch (err) {
+      console.error(`[aft-bridge] ERROR: active logger log threw: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(`[aft-bridge] ${message}`);
+    }
+  } else {
+    console.error(`[aft-bridge] ${message}`);
+  }
+}
+function warn(message, meta) {
+  const active = getActiveLogger();
+  if (active) {
+    try {
+      active.warn(message, meta);
+    } catch (err) {
+      console.error(`[aft-bridge] ERROR: active logger warn threw: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(`[aft-bridge] WARN: ${message}`);
+    }
+  } else {
+    console.error(`[aft-bridge] WARN: ${message}`);
+  }
+}
+function error(message, meta) {
+  const active = getActiveLogger();
+  if (active) {
+    try {
+      active.error(message, meta);
+    } catch (err) {
+      console.error(`[aft-bridge] ERROR: active logger error threw: ${err instanceof Error ? err.message : String(err)}`);
+      console.error(`[aft-bridge] ERROR: ${message}`);
+    }
+  } else {
+    console.error(`[aft-bridge] ERROR: ${message}`);
+  }
+}
+var ACTIVE_LOGGER_SYMBOL;
+var init_active_logger = __esm(() => {
+  ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
+});
+// ../aft-bridge/dist/status-bar.js
+function parseStatusBarCounts(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const record = value;
+  const num = (key) => {
+    const raw = record[key];
+    return typeof raw === "number" && Number.isFinite(raw) ? raw : 0;
+  };
+  return {
+    errors: num("errors"),
+    warnings: num("warnings"),
+    dead_code: num("dead_code"),
+    unused_exports: num("unused_exports"),
+    duplicates: num("duplicates"),
+    todos: num("todos"),
+    tier2_stale: record.tier2_stale === true
+  };
+}
+
+// ../aft-bridge/dist/bridge.js
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
 import { join } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+function tagStderrLine(line) {
+  return /^\[aft(-\w+)?\] /.test(line) ? line : `[aft] ${line}`;
+}
+function compareSemver(a, b) {
+  const [aMain, aPre] = a.split("-", 2);
+  const [bMain, bPre] = b.split("-", 2);
+  const aParts = aMain.split(".").map(Number);
+  const bParts = bMain.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    if (aParts[i] !== bParts[i])
+      return (aParts[i] ?? 0) - (bParts[i] ?? 0);
+  }
+  if (!aPre && !bPre)
+    return 0;
+  if (!aPre)
+    return 1;
+  if (!bPre)
+    return -1;
+  const aIds = aPre.split(".");
+  const bIds = bPre.split(".");
+  for (let i = 0;i < Math.max(aIds.length, bIds.length); i++) {
+    const ai = aIds[i];
+    const bi = bIds[i];
+    if (ai === undefined)
+      return -1;
+    if (bi === undefined)
+      return 1;
+    const aNum = /^\d+$/.test(ai);
+    const bNum = /^\d+$/.test(bi);
+    if (aNum && bNum) {
+      const diff = Number.parseInt(ai, 10) - Number.parseInt(bi, 10);
+      if (diff !== 0)
+        return diff;
+    } else if (aNum) {
+      return -1;
+    } else if (bNum) {
+      return 1;
+    } else {
+      const cmp = ai.localeCompare(bi);
+      if (cmp !== 0)
+        return cmp;
+    }
+  }
+  return 0;
+}
+function clampSemanticTimeout(configOverrides, bridgeTimeoutMs) {
+  const semantic = configOverrides.semantic;
+  if (!semantic || typeof semantic !== "object" || Array.isArray(semantic)) {
+    return configOverrides;
+  }
+  const timeoutMs = semantic.timeout_ms;
+  if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) {
+    return configOverrides;
+  }
+  const maxSemanticTimeoutMs = bridgeTimeoutMs > SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS ? bridgeTimeoutMs - SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS : Math.max(1, bridgeTimeoutMs - 1);
+  if (timeoutMs <= maxSemanticTimeoutMs) {
+    return configOverrides;
+  }
+  warn(`semantic.timeout_ms=${timeoutMs} exceeds bridge timeout budget; clamping to ${maxSemanticTimeoutMs}ms (bridge timeout: ${bridgeTimeoutMs}ms)`);
+  return {
+    ...configOverrides,
+    semantic: {
+      ...semantic,
+      timeout_ms: maxSemanticTimeoutMs
+    }
+  };
+}
+var DEFAULT_BRIDGE_TIMEOUT_MS = 30000, BRIDGE_HANG_TIMEOUT_THRESHOLD = 2, SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS = 5000, MAX_STDOUT_BUFFER, BridgeReplacedDuringVersionCheck, BinaryBridge;
+var init_bridge = __esm(() => {
+  init_active_logger();
+  MAX_STDOUT_BUFFER = 64 * 1024 * 1024;
+  BridgeReplacedDuringVersionCheck = class BridgeReplacedDuringVersionCheck extends Error {
+    newBinaryPath;
+    constructor(newBinaryPath) {
+      super(`Bridge binary replaced during version check: ${newBinaryPath}`);
+      this.newBinaryPath = newBinaryPath;
+      this.name = "BridgeReplacedDuringVersionCheck";
+    }
+  };
+  BinaryBridge = class BinaryBridge {
+    static RESTART_RESET_MS = 5 * 60 * 1000;
+    static STDERR_TAIL_MAX = 20;
+    binaryPath;
+    cwd;
+    process = null;
+    pending = new Map;
+    nextId = 1;
+    stdoutBuffer = "";
+    stderrBuffer = "";
+    stderrTail = [];
+    _restartCount = 0;
+    _shuttingDown = false;
+    timeoutMs;
+    maxRestarts;
+    configured = false;
+    _configurePromise = null;
+    configOverrides;
+    minVersion;
+    onVersionMismatch;
+    onConfigureWarnings;
+    onBashCompletion;
+    onBashLongRunning;
+    onBashPatternMatch;
+    cachedStatus = null;
+    statusListeners = new Set;
+    configureWarningClients = new Map;
+    restartResetTimer = null;
+    lastChildActivityAt = 0;
+    lastStatusBar;
+    consecutiveRequestTimeouts = 0;
+    errorPrefix;
+    logger;
+    childEnv;
+    constructor(binaryPath, cwd, options, configOverrides) {
+      this.binaryPath = binaryPath;
+      this.cwd = cwd;
+      this.timeoutMs = options?.timeoutMs ?? DEFAULT_BRIDGE_TIMEOUT_MS;
+      this.maxRestarts = options?.maxRestarts ?? 3;
+      this.configOverrides = clampSemanticTimeout(configOverrides ?? {}, this.timeoutMs);
+      this.minVersion = options?.minVersion;
+      this.onVersionMismatch = options?.onVersionMismatch;
+      this.onConfigureWarnings = options?.onConfigureWarnings;
+      this.onBashCompletion = options?.onBashCompletion;
+      this.onBashLongRunning = options?.onBashLongRunning;
+      this.onBashPatternMatch = options?.onBashPatternMatch;
+      this.errorPrefix = options?.errorPrefix ?? "[aft-bridge]";
+      this.logger = options?.logger;
+      this.childEnv = options?.childEnv;
+    }
+    logVia(message, meta) {
+      const logger = this.logger ?? getActiveLogger();
+      if (logger) {
+        try {
+          logger.log(message, meta);
+        } catch (err) {
+          console.error(`[aft-bridge] ERROR: logger log threw: ${err instanceof Error ? err.message : String(err)}`);
+          console.error(`[aft-bridge] ${message}`);
+        }
+      } else {
+        log(message, meta);
+      }
+    }
+    warnVia(message, meta) {
+      const logger = this.logger ?? getActiveLogger();
+      if (logger) {
+        try {
+          logger.warn(message, meta);
+        } catch (err) {
+          console.error(`[aft-bridge] ERROR: logger warn threw: ${err instanceof Error ? err.message : String(err)}`);
+          console.error(`[aft-bridge] WARN: ${message}`);
+        }
+      } else {
+        warn(message, meta);
+      }
+    }
+    errorVia(message, meta) {
+      const logger = this.logger ?? getActiveLogger();
+      if (logger) {
+        try {
+          logger.error(message, meta);
+        } catch (err) {
+          console.error(`[aft-bridge] ERROR: logger error threw: ${err instanceof Error ? err.message : String(err)}`);
+          console.error(`[aft-bridge] ERROR: ${message}`);
+        }
+      } else {
+        error(message, meta);
+      }
+    }
+    getLogFilePathVia() {
+      if (this.logger?.getLogFilePath) {
+        try {
+          return this.logger.getLogFilePath();
+        } catch (err) {
+          console.error(`[aft-bridge] ERROR: logger getLogFilePath threw: ${err instanceof Error ? err.message : String(err)}`);
+          return;
+        }
+      }
+      return getLogFilePath();
+    }
+    sessionLogVia(sessionId, message) {
+      this.logVia(message, sessionId ? { sessionId } : undefined);
+    }
+    sessionWarnVia(sessionId, message) {
+      this.warnVia(message, sessionId ? { sessionId } : undefined);
+    }
+    sessionErrorVia(sessionId, message) {
+      this.errorVia(message, sessionId ? { sessionId } : undefined);
+    }
+    get restartCount() {
+      return this._restartCount;
+    }
+    isAlive() {
+      return this.process !== null && this.process.exitCode === null && !this.process.killed;
+    }
+    hasPendingRequests() {
+      return this.pending.size > 0;
+    }
+    getCachedStatus() {
+      return this.cachedStatus;
+    }
+    subscribeStatus(listener) {
+      this.statusListeners.add(listener);
+      if (this.cachedStatus !== null) {
+        this.deliverStatusSnapshot(listener, this.cachedStatus);
+      }
+      return () => {
+        this.statusListeners.delete(listener);
+      };
+    }
+    cacheStatusSnapshot(snapshot) {
+      this.cachedStatus = snapshot;
+    }
+    async send(command, params = {}, options) {
+      return this.sendWithVersionMismatchRetry(command, params, options, true);
+    }
+    async sendWithVersionMismatchRetry(command, params, options, canRetryAfterVersionSwap) {
+      try {
+        if (this._shuttingDown) {
+          throw new Error(`${this.errorPrefix} Bridge is shutting down, cannot send "${command}"`);
+        }
+        if (Object.hasOwn(params, "id")) {
+          throw new Error("params cannot contain reserved key 'id'");
+        }
+        const requestSessionId = typeof params.session_id === "string" && params.session_id.length > 0 ? params.session_id : undefined;
+        this.ensureSpawned(requestSessionId);
+        if (requestSessionId && options?.configureWarningClient !== undefined) {
+          this.configureWarningClients.set(requestSessionId, options.configureWarningClient);
+        }
+        const effectiveTimeoutMs = options?.transportTimeoutMs ?? options?.timeoutMs ?? this.timeoutMs;
+        const implicitTransportOptions = {
+          ...options?.transportTimeoutMs !== undefined || options?.timeoutMs !== undefined ? { transportTimeoutMs: effectiveTimeoutMs } : {},
+          markConfiguredOnSuccess: false
+        };
+        if (!this.configured) {
+          if (command !== "configure" && command !== "version") {
+            if (!this._configurePromise) {
+              const sessionIdForConfigure = typeof params.session_id === "string" ? params.session_id : undefined;
+              this._configurePromise = (async () => {
+                try {
+                  const configResult = await this.send("configure", {
+                    project_root: this.cwd,
+                    ...this.configOverrides,
+                    ...sessionIdForConfigure ? { session_id: sessionIdForConfigure } : {}
+                  }, implicitTransportOptions);
+                  if (configResult.success === false) {
+                    throw new Error(`${this.errorPrefix} Configure failed: ${configResult.message ?? "unknown error"}`);
+                  }
+                  await this.deliverConfigureWarnings(configResult, params, options);
+                  await this.checkVersion(implicitTransportOptions);
+                  if (!this.isAlive()) {
+                    throw new Error(`${this.errorPrefix} Bridge died during version check. Check logs: ${this.getLogFilePathVia()}`);
+                  }
+                  this.configured = true;
+                } finally {
+                  this._configurePromise = null;
+                }
+              })();
+            }
+            await this._configurePromise;
+          }
+        }
+        const id = String(this.nextId++);
+        let request;
+        if (Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
+          const nested = { ...params };
+          const reserved = {};
+          for (const key of ["session_id", "lsp_hints"]) {
+            if (Object.hasOwn(nested, key)) {
+              reserved[key] = nested[key];
+              delete nested[key];
+            }
+          }
+          request = { id, command, ...reserved, params: nested };
+        } else {
+          request = { id, command, ...params };
+        }
+        const line = `${JSON.stringify(request)}
+`;
+        const keepBridgeOnTimeout = options?.keepBridgeOnTimeout === true;
+        let requestSentAt = Date.now();
+        const response = await new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            const entry = this.pending.get(id);
+            if (!entry)
+              return;
+            this.pending.delete(id);
+            clearTimeout(entry.timer);
+            if (keepBridgeOnTimeout) {
+              const timeoutMsg2 = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`;
+              if (requestSessionId) {
+                this.sessionWarnVia(requestSessionId, timeoutMsg2);
+              } else {
+                this.warnVia(timeoutMsg2);
+              }
+              entry.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
+              return;
+            }
+            const childActiveSinceRequest = this.lastChildActivityAt > requestSentAt;
+            const consecutiveTimeouts = this.consecutiveRequestTimeouts + 1;
+            this.consecutiveRequestTimeouts = consecutiveTimeouts;
+            const keepWarm = childActiveSinceRequest || consecutiveTimeouts < BRIDGE_HANG_TIMEOUT_THRESHOLD;
+            const restartSuffix = keepWarm ? " — bridge kept warm" : " — restarting bridge";
+            const timeoutMsg = `Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms${restartSuffix}`;
+            if (requestSessionId) {
+              this.sessionWarnVia(requestSessionId, timeoutMsg);
+            } else {
+              this.warnVia(timeoutMsg);
+            }
+            if (keepWarm) {
+              entry.reject(new Error(`${this.errorPrefix} request "${command}" timed out after ${effectiveTimeoutMs}ms (bridge busy/under load); bridge kept warm — retry`));
+              return;
+            }
+            entry.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
+            this.handleTimeout(requestSessionId);
+          }, effectiveTimeoutMs);
+          this.pending.set(id, { resolve, reject, timer, onProgress: options?.onProgress });
+          if (!this.process?.stdin?.writable) {
+            this.pending.delete(id);
+            clearTimeout(timer);
+            reject(new Error(`${this.errorPrefix} stdin not writable for command "${command}"`));
+            return;
+          }
+          requestSentAt = Date.now();
+          this.process.stdin.write(line, (err) => {
+            if (err) {
+              const entry = this.pending.get(id);
+              if (entry) {
+                this.pending.delete(id);
+                clearTimeout(entry.timer);
+                entry.reject(new Error(`${this.errorPrefix} Failed to write to stdin: ${err.message}`));
+              }
+            }
+          });
+        });
+        if (command === "configure" && response.success === true && options?.markConfiguredOnSuccess !== false) {
+          this.configured = true;
+        }
+        return response;
+      } catch (err) {
+        if (err instanceof BridgeReplacedDuringVersionCheck && canRetryAfterVersionSwap && command !== "configure" && command !== "version") {
+          this.logVia(`Retrying request "${command}" once after coordinated binary replacement: ${err.newBinaryPath}`);
+          return this.sendWithVersionMismatchRetry(command, params, options, false);
+        }
+        throw err;
+      }
+    }
+    async deliverConfigureWarnings(configResult, params, options) {
+      if (!this.onConfigureWarnings || !Array.isArray(configResult.warnings))
+        return;
+      if (configResult.warnings.length === 0)
+        return;
+      const sessionId = typeof params.session_id === "string" ? params.session_id : undefined;
+      try {
+        await this.onConfigureWarnings({
+          projectRoot: this.cwd,
+          sessionId,
+          client: options?.configureWarningClient ?? (sessionId ? this.configureWarningClients.get(sessionId) : undefined),
+          warnings: configResult.warnings
+        });
+      } catch (err) {
+        this.warnVia(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+      } finally {
+        if (sessionId) {
+          this.configureWarningClients.delete(sessionId);
+        }
+      }
+    }
+    async handleConfigureWarningsFrame(frame) {
+      if (!this.onConfigureWarnings)
+        return;
+      const warnings = frame.warnings;
+      if (!Array.isArray(warnings) || warnings.length === 0)
+        return;
+      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;
+      try {
+        await this.onConfigureWarnings({
+          projectRoot,
+          sessionId,
+          client: sessionId ? this.configureWarningClients.get(sessionId) : undefined,
+          warnings
+        });
+      } finally {
+        if (sessionId) {
+          this.configureWarningClients.delete(sessionId);
+        }
+      }
+    }
+    handleStatusChangedFrame(frame) {
+      const snapshot = frame.snapshot;
+      if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot))
+        return;
+      this.cachedStatus = snapshot;
+      this.logVia("Received status_changed push frame; cached AFT status snapshot");
+      for (const listener of this.statusListeners) {
+        this.deliverStatusSnapshot(listener, this.cachedStatus);
+      }
+    }
+    deliverStatusSnapshot(listener, snapshot) {
+      try {
+        listener(snapshot);
+      } catch (err) {
+        this.warnVia(`status listener threw: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    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;
+        this.process = null;
+        return new Promise((resolve) => {
+          const forceKillTimer = setTimeout(() => {
+            proc.kill("SIGKILL");
+            resolve();
+          }, 5000);
+          proc.once("exit", () => {
+            clearTimeout(forceKillTimer);
+            this.logVia("Process exited during shutdown");
+            resolve();
+          });
+          proc.kill("SIGTERM");
+        });
+      }
+    }
+    async checkVersion(options) {
+      if (!this.minVersion)
+        return;
+      try {
+        const resp = await this.send("version", {}, options);
+        if (resp.success === false) {
+          throw new Error(`Binary version check failed: ${String(resp.code ?? "unknown")} — likely too old`);
+        }
+        const binaryVersion = resp.version;
+        if (typeof binaryVersion !== "string") {
+          throw new Error(`Binary did not report a version — likely too old (minVersion: ${this.minVersion})`);
+        }
+        this.logVia(`Binary version: ${binaryVersion}`);
+        if (compareSemver(binaryVersion, this.minVersion) < 0) {
+          this.warnVia(`Binary version ${binaryVersion} is older than required ${this.minVersion}`);
+          const replacementPath = await this.onVersionMismatch?.(binaryVersion, this.minVersion);
+          if (replacementPath === undefined) {
+            return;
+          }
+          if (replacementPath === null || replacementPath.length === 0) {
+            throw new Error(`Binary version ${binaryVersion} is older than required ${this.minVersion}; no compatible replacement binary was provided`);
+          }
+          await this.replaceCurrentBinary(replacementPath);
+          throw new BridgeReplacedDuringVersionCheck(replacementPath);
+        }
+      } catch (err) {
+        this.warnVia(`Version check failed: ${err.message}`);
+        throw err;
+      }
+    }
+    async replaceCurrentBinary(newBinaryPath) {
+      this.binaryPath = newBinaryPath;
+      this.configured = false;
+      this.clearRestartResetTimer();
+      this.rejectAllPending(new Error(`${this.errorPrefix} Bridge restarting with updated binary: ${newBinaryPath}`));
+      if (!this.process)
+        return;
+      const proc = this.process;
+      this.process = null;
+      await new Promise((resolve) => {
+        const forceKillTimer = setTimeout(() => {
+          proc.kill("SIGKILL");
+          resolve();
+        }, 5000);
+        proc.once("exit", () => {
+          clearTimeout(forceKillTimer);
+          this.logVia("Process exited during coordinated binary replacement");
+          resolve();
+        });
+        proc.kill("SIGTERM");
+      });
+    }
+    ensureSpawned(triggeringSessionId) {
+      if (this.isAlive())
+        return;
+      this.spawnProcess(triggeringSessionId);
+    }
+    spawnProcess(triggeringSessionId) {
+      this.lastStatusBar = undefined;
+      if (triggeringSessionId) {
+        this.sessionLogVia(triggeringSessionId, `Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
+      } else {
+        this.logVia(`Spawning binary: ${this.binaryPath} (cwd: ${this.cwd})`);
+      }
+      const semantic = this.configOverrides.semantic;
+      const semanticBackend = (() => {
+        if (semantic && typeof semantic === "object" && !Array.isArray(semantic)) {
+          const candidate = semantic.backend;
+          return typeof candidate === "string" ? candidate : undefined;
+        }
+        return;
+      })();
+      const useFastembedBackend = semanticBackend === undefined || semanticBackend === "fastembed" || semanticBackend === "";
+      const ortDir = typeof this.configOverrides._ort_dylib_dir === "string" && useFastembedBackend ? this.configOverrides._ort_dylib_dir : null;
+      const ortLibraryPath = ortDir == null ? null : join(ortDir, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
+      const envPath = process.platform === "win32" && ortDir ? `${ortDir};${process.env.PATH ?? ""}` : process.env.PATH;
+      const env = {
+        ...process.env,
+        ...envPath ? { PATH: envPath } : {}
+      };
+      this.logVia(`bridge.spawnProcess: useFastembedBackend=${useFastembedBackend}, ` + `parentORT=${process.env.ORT_DYLIB_PATH ?? "(unset)"}, ` + `ortLibraryPath=${ortLibraryPath ?? "(none)"}`);
+      if (useFastembedBackend) {
+        env.FASTEMBED_CACHE_DIR = process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join(this.configOverrides.storage_dir, "semantic", "models") : join(homedir() || "", ".cache", "fastembed"));
+        if (process.env.ORT_DYLIB_PATH) {
+          this.logVia(`ORT_DYLIB_PATH inherited from parent env: ${process.env.ORT_DYLIB_PATH}`);
+        } else if (ortLibraryPath) {
+          env.ORT_DYLIB_PATH = ortLibraryPath;
+          this.logVia(`ORT_DYLIB_PATH set from managed ONNX Runtime: ${ortLibraryPath}`);
+        }
+      }
+      if (this.childEnv) {
+        for (const [key, value] of Object.entries(this.childEnv)) {
+          if (value === undefined) {
+            delete env[key];
+          } else {
+            env[key] = value;
+          }
+        }
+      }
+      const child = spawn(this.binaryPath, [], {
+        cwd: this.cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        env
+      });
+      const currentChild = child;
+      const stdoutDecoder = new StringDecoder("utf8");
+      child.stdout?.on("data", (chunk) => {
+        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) => {
+        this.onStderrData(stderrDecoder.write(chunk));
+      });
+      child.stderr?.on("end", () => {
+        const remaining = stderrDecoder.end();
+        if (remaining)
+          this.onStderrData(remaining);
+        this.flushStderrBuffer();
+      });
+      child.on("error", (err) => {
+        if (this.process !== currentChild)
+          return;
+        this.errorVia(`Process error: ${err.message}${this.formatStderrTail()}`);
+        this.handleCrash();
+      });
+      child.on("exit", (code, signal) => {
+        if (this.process !== currentChild)
+          return;
+        if (this._shuttingDown)
+          return;
+        this.logVia(`Process exited: code=${code}, signal=${signal}`);
+        if (signal === "SIGTERM" || signal === "SIGKILL" || signal === "SIGHUP" || signal === "SIGINT") {
+          this.process = null;
+          this.configured = false;
+          this.clearRestartResetTimer();
+          this.rejectAllPending(new Error(`${this.errorPrefix} Binary killed by ${signal}`));
+          return;
+        }
+        this.handleCrash();
+      });
+      this.process = child;
+      this.stdoutBuffer = "";
+      this.stderrBuffer = "";
+      this.lastChildActivityAt = 0;
+      this.consecutiveRequestTimeouts = 0;
+      this.stderrTail = [];
+    }
+    pushStderrLine(line) {
+      this.stderrTail.push(line);
+      if (this.stderrTail.length > BinaryBridge.STDERR_TAIL_MAX) {
+        this.stderrTail.shift();
+      }
+    }
+    onStderrData(data) {
+      this.stderrBuffer += data;
+      let newlineIdx;
+      while ((newlineIdx = this.stderrBuffer.indexOf(`
+`)) !== -1) {
+        const line = this.stderrBuffer.slice(0, newlineIdx).replace(/\r$/, "");
+        this.stderrBuffer = this.stderrBuffer.slice(newlineIdx + 1);
+        if (!line)
+          continue;
+        const tagged = tagStderrLine(line);
+        this.logVia(tagged);
+        this.pushStderrLine(tagged);
+      }
+    }
+    flushStderrBuffer() {
+      const line = this.stderrBuffer.replace(/\r$/, "");
+      this.stderrBuffer = "";
+      if (!line)
+        return;
+      const tagged = tagStderrLine(line);
+      this.logVia(tagged);
+      this.pushStderrLine(tagged);
+    }
+    formatStderrTail() {
+      if (this.stderrTail.length === 0)
+        return "";
+      const tail = this.stderrTail.join(`
+  `);
+      return `
+  --- last ${this.stderrTail.length} stderr lines ---
+  ${tail}`;
+    }
+    onStdoutData(data) {
+      this.stdoutBuffer += data;
+      if (this.stdoutBuffer.length > MAX_STDOUT_BUFFER) {
+        this.handleCrash(new Error(`aft bridge stdout buffer exceeded ${MAX_STDOUT_BUFFER} bytes — killing bridge`));
+        return;
+      }
+      let newlineIdx;
+      while ((newlineIdx = this.stdoutBuffer.indexOf(`
+`)) !== -1) {
+        const line = this.stdoutBuffer.slice(0, newlineIdx).trim();
+        this.stdoutBuffer = this.stdoutBuffer.slice(newlineIdx + 1);
+        if (!line)
+          continue;
+        try {
+          const response = JSON.parse(line);
+          this.lastChildActivityAt = Date.now();
+          if (response.type === "progress") {
+            const requestId = response.request_id;
+            const entry = requestId ? this.pending.get(requestId) : undefined;
+            const kind = response.kind === "stderr" ? "stderr" : "stdout";
+            const text = typeof response.chunk === "string" ? response.chunk : "";
+            entry?.onProgress?.({ kind, text });
+            continue;
+          }
+          if (response.type === "permission_ask") {
+            const requestId = response.request_id;
+            const entry = requestId ? this.pending.get(requestId) : undefined;
+            if (requestId && entry) {
+              this.pending.delete(requestId);
+              clearTimeout(entry.timer);
+              entry.resolve({
+                success: false,
+                code: "permission_required",
+                message: "bash command requires permission",
+                asks: response.asks
+              });
+            }
+            continue;
+          }
+          if (response.type === "bash_completed") {
+            this.onBashCompletion?.(response, this);
+            continue;
+          }
+          if (response.type === "bash_long_running") {
+            this.onBashLongRunning?.(response, this);
+            continue;
+          }
+          if (response.type === "bash_pattern_match") {
+            this.onBashPatternMatch?.(response, this);
+            continue;
+          }
+          if (response.type === "configure_warnings") {
+            this.handleConfigureWarningsFrame(response).catch((err) => {
+              this.warnVia(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+            });
+            continue;
+          }
+          if (response.type === "status_changed") {
+            this.handleStatusChangedFrame(response);
+            continue;
+          }
+          const id = response.id;
+          if (id && this.pending.has(id)) {
+            const entry = this.pending.get(id);
+            if (!entry)
+              continue;
+            this.pending.delete(id);
+            clearTimeout(entry.timer);
+            this.consecutiveRequestTimeouts = 0;
+            this.scheduleRestartCountReset();
+            this.captureStatusBar(response);
+            entry.resolve(response);
+          } else if (typeof response.type === "string") {
+            this.logVia(`Ignoring unknown stdout push frame type: ${response.type}`);
+          }
+        } catch (_err) {
+          this.warnVia(`Failed to parse stdout line: ${line}`);
+        }
+      }
+    }
+    captureStatusBar(response) {
+      const parsed = parseStatusBarCounts(response.status_bar);
+      if (parsed)
+        this.lastStatusBar = parsed;
+    }
+    getStatusBar() {
+      return this.lastStatusBar;
+    }
+    handleTimeout(triggeringSessionId) {
+      this.consecutiveRequestTimeouts = 0;
+      this.rejectAllPending(new Error(`${this.errorPrefix} bridge killed during sibling timeout — request aborted`));
+      if (this.process) {
+        this.process.kill("SIGKILL");
+        this.process = null;
+      }
+      this.clearRestartResetTimer();
+      this.configured = false;
+      const tail = this.formatStderrTail();
+      this.stderrTail = [];
+      const killedMsg = tail ? `Bridge killed after timeout.${tail}` : `Bridge killed after timeout (see ${this.getLogFilePathVia()})`;
+      if (tail) {
+        if (triggeringSessionId) {
+          this.sessionErrorVia(triggeringSessionId, killedMsg);
+        } else {
+          this.errorVia(killedMsg);
+        }
+      } else if (triggeringSessionId) {
+        this.sessionWarnVia(triggeringSessionId, killedMsg);
+      } else {
+        this.warnVia(killedMsg);
+      }
+    }
+    handleCrash(cause) {
+      const proc = this.process;
+      this.process = null;
+      if (proc && proc.exitCode === null && !proc.killed) {
+        proc.kill("SIGKILL");
+      }
+      this.clearRestartResetTimer();
+      this.configured = false;
+      const tail = this.formatStderrTail();
+      if (tail) {
+        this.errorVia(`Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""}.${tail}`);
+      }
+      this.rejectAllPending(new Error(`${this.errorPrefix} Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""} (see ${this.getLogFilePathVia()})`));
+      if (this._restartCount < this.maxRestarts) {
+        const delay = 100 * 2 ** this._restartCount;
+        this._restartCount++;
+        this.logVia(`Auto-restart #${this._restartCount} in ${delay}ms`);
+        setTimeout(() => {
+          if (!this._shuttingDown && !this.isAlive()) {
+            try {
+              this.spawnProcess();
+            } catch (err) {
+              this.errorVia(`Failed to restart: ${err.message}`);
+            }
+          }
+        }, delay);
+        this.scheduleRestartCountReset();
+      } else {
+        this.errorVia(`Max restarts (${this.maxRestarts}) reached, giving up. Logs: ${this.getLogFilePathVia()}${tail}`);
+        this.scheduleRestartCountReset();
+      }
+    }
+    rejectAllPending(error2) {
+      for (const [_id, entry] of this.pending) {
+        clearTimeout(entry.timer);
+        entry.reject(error2);
+      }
+      this.pending.clear();
+    }
+    scheduleRestartCountReset() {
+      this.clearRestartResetTimer();
+      this.restartResetTimer = setTimeout(() => {
+        this._restartCount = 0;
+        this.restartResetTimer = null;
+      }, BinaryBridge.RESTART_RESET_MS);
+    }
+    clearRestartResetTimer() {
+      if (this.restartResetTimer) {
+        clearTimeout(this.restartResetTimer);
+        this.restartResetTimer = null;
+      }
+    }
+  };
+});
+
+// ../aft-bridge/dist/platform.js
+var init_platform = () => {};
+
+// ../aft-bridge/dist/downloader.js
+var MAX_DOWNLOAD_BYTES, DOWNLOAD_LOCK_STALE_MS;
+var init_downloader = __esm(() => {
+  init_active_logger();
+  init_platform();
+  MAX_DOWNLOAD_BYTES = 200 * 1024 * 1024;
+  DOWNLOAD_LOCK_STALE_MS = 10 * 60000;
+});
+// ../aft-bridge/dist/paths.js
+var init_paths = () => {};
+
+// ../aft-bridge/dist/resolver.js
+import { chmodSync, closeSync, copyFileSync, existsSync, mkdirSync, openSync, readSync, renameSync, unlinkSync } from "node:fs";
+function isNativeExecutable(binaryPath) {
+  let fd = null;
+  try {
+    fd = openSync(binaryPath, "r");
+    const buf = Buffer.alloc(4);
+    const read = readSync(fd, buf, 0, 4, 0);
+    if (read < 2)
+      return false;
+    const b0 = buf[0];
+    const b1 = buf[1];
+    if (b0 === 35 && b1 === 33)
+      return false;
+    const m32 = buf.readUInt32BE(0);
+    const machO = new Set([4277009102, 4277009103, 3472551422, 3489328638, 3405691582]);
+    if (read >= 4 && machO.has(m32))
+      return true;
+    if (read >= 4 && m32 === 2135247942)
+      return true;
+    if (b0 === 77 && b1 === 90)
+      return true;
+    return false;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {}
+    }
+  }
+}
+var init_resolver = __esm(() => {
+  init_active_logger();
+  init_downloader();
+  init_platform();
+});
+
+// ../aft-bridge/dist/migration.js
+var DEFAULT_TIMEOUT_MS;
+var init_migration = __esm(() => {
+  init_paths();
+  init_resolver();
+  DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+});
+
+// ../aft-bridge/dist/onnx-runtime.js
+var ORT_VERSION = "1.24.4", MAX_DOWNLOAD_BYTES2, MAX_EXTRACT_BYTES, STALE_LOCK_MS, ORT_PLATFORM_MAP;
+var init_onnx_runtime = __esm(() => {
+  init_active_logger();
+  init_platform();
+  MAX_DOWNLOAD_BYTES2 = 256 * 1024 * 1024;
+  MAX_EXTRACT_BYTES = 1 * 1024 * 1024 * 1024;
+  STALE_LOCK_MS = 5 * 60 * 1000;
+  ORT_PLATFORM_MAP = {
+    darwin: {
+      arm64: {
+        assetName: `onnxruntime-osx-arm64-${ORT_VERSION}`,
+        libName: "libonnxruntime.dylib",
+        archiveType: "tgz"
+      }
+    },
+    linux: {
+      x64: {
+        assetName: `onnxruntime-linux-x64-${ORT_VERSION}`,
+        libName: "libonnxruntime.so",
+        archiveType: "tgz"
+      },
+      arm64: {
+        assetName: `onnxruntime-linux-aarch64-${ORT_VERSION}`,
+        libName: "libonnxruntime.so",
+        archiveType: "tgz"
+      }
+    },
+    win32: {
+      x64: {
+        assetName: `onnxruntime-win-x64-${ORT_VERSION}`,
+        libName: "onnxruntime.dll",
+        archiveType: "zip"
+      },
+      arm64: {
+        assetName: `onnxruntime-win-arm64-${ORT_VERSION}`,
+        libName: "onnxruntime.dll",
+        archiveType: "zip"
+      }
+    }
+  };
+});
+
+// ../aft-bridge/dist/pool.js
+import { realpathSync } from "node:fs";
+
+class BridgePool {
+  bridges = new Map;
+  staleBridges = new Set;
+  binaryPath;
+  maxPoolSize;
+  idleTimeoutMs;
+  bridgeOptions;
+  configOverrides;
+  projectConfigLoader;
+  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.projectConfigLoader = options.projectConfigLoader;
+    this.bridgeOptions = {
+      timeoutMs: options.timeoutMs,
+      maxRestarts: options.maxRestarts,
+      minVersion: options.minVersion,
+      onVersionMismatch: options.onVersionMismatch,
+      onConfigureWarnings: options.onConfigureWarnings,
+      onBashCompletion: options.onBashCompletion,
+      onBashLongRunning: options.onBashLongRunning,
+      onBashPatternMatch: options.onBashPatternMatch,
+      errorPrefix: options.errorPrefix,
+      logger: options.logger,
+      childEnv: options.childEnv
+    };
+    this.configOverrides = configOverrides;
+    if (Number.isFinite(this.idleTimeoutMs)) {
+      this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+      this.cleanupTimer.unref();
+    }
+  }
+  getActiveBridgeForRoot(projectRoot) {
+    const key = normalizeKey(projectRoot);
+    const entry = this.bridges.get(key);
+    if (!entry?.bridge.isAlive())
+      return null;
+    entry.lastUsed = Date.now();
+    return entry.bridge;
+  }
+  getBridge(projectRoot) {
+    const key = normalizeKey(projectRoot);
+    const existing = this.bridges.get(key);
+    if (existing) {
+      existing.lastUsed = Date.now();
+      return existing.bridge;
+    }
+    if (this.bridges.size >= this.maxPoolSize) {
+      this.evictLRU();
+    }
+    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;
+  }
+  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) => this.error("cleanup shutdown failed:", err));
+        this.bridges.delete(dir);
+      }
+    }
+    for (const bridge of this.staleBridges) {
+      if (bridge.hasPendingRequests())
+        continue;
+      bridge.shutdown().catch((err) => this.error("stale cleanup shutdown failed:", err));
+      this.staleBridges.delete(bridge);
+    }
+  }
+  evictLRU() {
+    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;
+      }
+    }
+    if (oldestDir) {
+      const entry = this.bridges.get(oldestDir);
+      entry?.bridge.shutdown().catch((err) => this.error("eviction shutdown failed:", err));
+      this.bridges.delete(oldestDir);
+    }
+  }
+  async shutdown() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    const shutdowns = [
+      ...Array.from(this.bridges.values(), (e) => e.bridge.shutdown()),
+      ...Array.from(this.staleBridges.values(), (bridge) => bridge.shutdown())
+    ];
+    this.bridges.clear();
+    this.staleBridges.clear();
+    await Promise.allSettled(shutdowns);
+  }
+  async replaceBinary(newPath) {
+    this.binaryPath = newPath;
+    for (const entry of this.bridges.values()) {
+      this.staleBridges.add(entry.bridge);
+    }
+    this.bridges.clear();
+    this.log(`Binary path updated to ${newPath}. Active bridges marked stale — next calls will use the new binary.`);
+    return newPath;
+  }
+  log(message, meta) {
+    const logger = this.logger ?? getActiveLogger();
+    if (logger) {
+      try {
+        logger.log(message, meta);
+      } catch (err) {
+        console.error(`[aft-bridge] ERROR: pool logger log threw: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[aft-bridge] ${message}`);
+      }
+    } else
+      log(message, meta);
+  }
+  error(message, meta) {
+    const logger = this.logger ?? getActiveLogger();
+    if (logger) {
+      try {
+        logger.error(message, meta);
+      } catch (err) {
+        console.error(`[aft-bridge] ERROR: pool logger error threw: ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`[aft-bridge] ERROR: ${message}`);
+      }
+    } else
+      error(message, meta);
+  }
+  setConfigureOverride(key, value) {
+    if (value === undefined) {
+      delete this.configOverrides[key];
+    } else {
+      this.configOverrides[key] = value;
+    }
+  }
+  get size() {
+    return this.bridges.size;
+  }
+  _testGetConfigOverrides() {
+    return { ...this.configOverrides };
+  }
+  _testGetBridgeOptions() {
+    return { ...this.bridgeOptions };
+  }
+}
+function normalizeKey(projectRoot) {
+  const stripped = projectRoot.replace(/[/\\]+$/, "");
+  try {
+    return realpathSync(stripped);
+  } catch {
+    return stripped;
+  }
+}
+var DEFAULT_IDLE_TIMEOUT_MS = Infinity, DEFAULT_MAX_POOL_SIZE = 8, CLEANUP_INTERVAL_MS;
+var init_pool = __esm(() => {
+  init_active_logger();
+  init_bridge();
+  CLEANUP_INTERVAL_MS = 60 * 1000;
+});
+// ../aft-bridge/dist/index.js
+var init_dist = __esm(() => {
+  init_active_logger();
+  init_bridge();
+  init_downloader();
+  init_migration();
+  init_onnx_runtime();
+  init_paths();
+  init_platform();
+  init_pool();
+  init_resolver();
+});
+
+// src/lib/paths.ts
+import { homedir as homedir2, tmpdir } from "node:os";
+import { join as join2 } from "node:path";
 function getAftBinaryCacheDir() {
   if (process.env.AFT_CACHE_DIR) {
-    return join(process.env.AFT_CACHE_DIR, "bin");
+    return join2(process.env.AFT_CACHE_DIR, "bin");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join(homedir(), "AppData", "Local");
-    return join(base2, "aft", "bin");
+    const base2 = localAppData || join2(homedir2(), "AppData", "Local");
+    return join2(base2, "aft", "bin");
   }
-  const base = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
-  return join(base, "aft", "bin");
+  const base = process.env.XDG_CACHE_HOME || join2(homedir2(), ".cache");
+  return join2(base, "aft", "bin");
 }
 function getAftBinaryName() {
   return process.platform === "win32" ? "aft.exe" : "aft";
 }
 function getAftLspPackagesDir() {
   if (process.env.AFT_CACHE_DIR) {
-    return join(process.env.AFT_CACHE_DIR, "lsp-packages");
+    return join2(process.env.AFT_CACHE_DIR, "lsp-packages");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join(homedir(), "AppData", "Local");
-    return join(base2, "aft", "lsp-packages");
+    const base2 = localAppData || join2(homedir2(), "AppData", "Local");
+    return join2(base2, "aft", "lsp-packages");
   }
-  const base = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
-  return join(base, "aft", "lsp-packages");
+  const base = process.env.XDG_CACHE_HOME || join2(homedir2(), ".cache");
+  return join2(base, "aft", "lsp-packages");
 }
 function getAftLspBinariesDir() {
   if (process.env.AFT_CACHE_DIR) {
-    return join(process.env.AFT_CACHE_DIR, "lsp-binaries");
+    return join2(process.env.AFT_CACHE_DIR, "lsp-binaries");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join(homedir(), "AppData", "Local");
-    return join(base2, "aft", "lsp-binaries");
+    const base2 = localAppData || join2(homedir2(), "AppData", "Local");
+    return join2(base2, "aft", "lsp-binaries");
   }
-  const base = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
-  return join(base, "aft", "lsp-binaries");
+  const base = process.env.XDG_CACHE_HOME || join2(homedir2(), ".cache");
+  return join2(base, "aft", "lsp-binaries");
 }
 function homeDir() {
   if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir();
-  return process.env.HOME || homedir();
+    return process.env.USERPROFILE || process.env.HOME || homedir2();
+  return process.env.HOME || homedir2();
 }
 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 || join(homeDir(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join2(homeDir(), "AppData", "Local");
   }
-  return join(homeDir(), ".local", "share");
+  return join2(homeDir(), ".local", "share");
 }
 function getCortexKitStorageRoot() {
-  return join(dataHome(), "cortexkit", "aft");
+  return join2(dataHome(), "cortexkit", "aft");
 }
 function getTmpLogPath(filename) {
-  return join(tmpdir(), filename);
+  return join2(tmpdir(), filename);
 }
-var init_paths = () => {};
+var init_paths2 = () => {};
 
 // src/lib/binary-probe.ts
 import { execSync, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { createRequire } from "node:module";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
 async function loadPluginVersion() {
   try {
     const bridgePackageName = "@cortexkit/aft-bridge";
@@ -167,7 +1334,7 @@ function probeAftBinary(preferredVersion) {
   const candidates = [];
   for (const candidate of aftBinaryCandidates(preferredVersion)) {
     try {
-      if (!existsSync(candidate))
+      if (!existsSync2(candidate))
         continue;
       const result = spawnSync(candidate, ["--version"], {
         stdio: ["ignore", "pipe", "pipe"],
@@ -198,12 +1365,12 @@ ${result.stderr ?? ""}`.trim();
       }
       candidates.push({ path: candidate, status: "matched", version, output });
       return { version, path: candidate, expectedVersion, expectedMajorMinor, candidates };
-    } catch (error) {
+    } catch (error2) {
       candidates.push({
         path: candidate,
         status: "error",
         version: null,
-        error: error instanceof Error ? error.message : String(error)
+        error: error2 instanceof Error ? error2.message : String(error2)
       });
     }
   }
@@ -218,14 +1385,14 @@ function pushCandidate(candidates, candidate) {
 function firstExisting(candidates) {
   for (const candidate of candidates) {
     try {
-      if (!existsSync(candidate))
+      if (!existsSync2(candidate))
         continue;
       return candidate;
     } catch {}
   }
   return null;
 }
-function platformKey(platform = process.platform, arch = process.arch) {
+function platformKey2(platform = process.platform, arch = process.arch) {
   const table = {
     darwin: { arm64: "darwin-arm64", x64: "darwin-x64" },
     linux: { arm64: "linux-arm64", x64: "linux-x64" },
@@ -237,9 +1404,9 @@ function aftBinaryCandidates(preferredVersion) {
   const candidates = [];
   if (preferredVersion) {
     const tag = preferredVersion.startsWith("v") ? preferredVersion : `v${preferredVersion}`;
-    pushCandidate(candidates, join2(getAftBinaryCacheDir(), tag, getAftBinaryName()));
+    pushCandidate(candidates, join3(getAftBinaryCacheDir(), tag, getAftBinaryName()));
   }
-  const key = platformKey();
+  const key = platformKey2();
   if (key) {
     try {
       const require2 = createRequire(import.meta.url);
@@ -253,11 +1420,14 @@ function aftBinaryCandidates(preferredVersion) {
       encoding: "utf-8",
       env: process.env
     }).trim();
-    if (resolved) {
-      pushCandidate(candidates, resolved.split(/\r?\n/)[0]);
+    for (const line of resolved.split(/\r?\n/)) {
+      const candidate = line.trim();
+      if (candidate && isNativeExecutable(candidate)) {
+        pushCandidate(candidates, candidate);
+      }
     }
   } catch {}
-  pushCandidate(candidates, join2(homedir2(), ".cargo", "bin", getAftBinaryName()));
+  pushCandidate(candidates, join3(homedir3(), ".cargo", "bin", getAftBinaryName()));
   return candidates;
 }
 function findAftBinary(preferredVersion) {
@@ -265,16 +1435,17 @@ function findAftBinary(preferredVersion) {
 }
 var PLUGIN_VERSION, VERSION_LINE;
 var init_binary_probe = __esm(async () => {
-  init_paths();
+  init_dist();
+  init_paths2();
   PLUGIN_VERSION = await loadPluginVersion();
   VERSION_LINE = /^(?:aft\s+)?v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)$/i;
 });
 
 // src/lib/fs-util.ts
-import { existsSync as existsSync2, readdirSync, statSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync3, readdirSync, statSync } from "node:fs";
+import { join as join4 } from "node:path";
 function dirSize(path) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return 0;
   }
   const stat = statSync(path);
@@ -286,7 +1457,7 @@ function dirSize(path) {
   }
   let total = 0;
   for (const entry of readdirSync(path)) {
-    total += dirSize(join3(path, entry));
+    total += dirSize(join4(path, entry));
   }
   return total;
 }
@@ -4840,45 +6011,45 @@ var require_esprima = __commonJS((exports, module) => {
             this.errors = [];
             this.tolerant = false;
           }
-          ErrorHandler2.prototype.recordError = function(error) {
-            this.errors.push(error);
+          ErrorHandler2.prototype.recordError = function(error2) {
+            this.errors.push(error2);
           };
-          ErrorHandler2.prototype.tolerate = function(error) {
+          ErrorHandler2.prototype.tolerate = function(error2) {
             if (this.tolerant) {
-              this.recordError(error);
+              this.recordError(error2);
             } else {
-              throw error;
+              throw error2;
             }
           };
           ErrorHandler2.prototype.constructError = function(msg, column) {
-            var error = new Error(msg);
+            var error2 = new Error(msg);
             try {
-              throw error;
+              throw error2;
             } catch (base) {
               if (Object.create && Object.defineProperty) {
-                error = Object.create(base);
-                Object.defineProperty(error, "column", { value: column });
+                error2 = Object.create(base);
+                Object.defineProperty(error2, "column", { value: column });
               }
             }
-            return error;
+            return error2;
           };
           ErrorHandler2.prototype.createError = function(index, line, col, description) {
             var msg = "Line " + line + ": " + description;
-            var error = this.constructError(msg, col);
-            error.index = index;
-            error.lineNumber = line;
-            error.description = description;
-            return error;
+            var error2 = this.constructError(msg, col);
+            error2.index = index;
+            error2.lineNumber = line;
+            error2.description = description;
+            return error2;
           };
           ErrorHandler2.prototype.throwError = function(index, line, col, description) {
             throw this.createError(index, line, col, description);
           };
           ErrorHandler2.prototype.tolerateError = function(index, line, col, description) {
-            var error = this.createError(index, line, col, description);
+            var error2 = this.createError(index, line, col, description);
             if (this.tolerant) {
-              this.recordError(error);
+              this.recordError(error2);
             } else {
-              throw error;
+              throw error2;
             }
           };
           return ErrorHandler2;
@@ -7548,19 +8719,19 @@ var require_parse = __commonJS((exports, module) => {
   var symbolFor = (prefix) => Symbol.for(last_prop !== UNDEFINED ? prefix + COLON + last_prop : prefix);
   var transform = (k, { value, context = {} }) => reviver ? reviver(k, value, context) : value;
   var unexpected = () => {
-    const error = new SyntaxError(`Unexpected token '${current.value.slice(0, 1)}', "${current_code}" is not valid JSON`);
-    Object.assign(error, current.loc.start);
+    const error2 = new SyntaxError(`Unexpected token '${current.value.slice(0, 1)}', "${current_code}" is not valid JSON`);
+    Object.assign(error2, current.loc.start);
     free();
-    throw error;
+    throw error2;
   };
   var unexpected_end = () => {
-    const error = new SyntaxError("Unexpected end of JSON input");
-    Object.assign(error, last ? last.loc.end : {
+    const error2 = new SyntaxError("Unexpected end of JSON input");
+    Object.assign(error2, last ? last.loc.end : {
       line: 1,
       column: 0
     });
     free();
-    throw error;
+    throw error2;
   };
   var next = () => {
     const new_token = tokens[++index];
@@ -7909,10 +9080,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join4 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join5 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join4(comment, inside, gap);
+    return join5(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -7934,13 +9105,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join4(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join5(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 += join4(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join5(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) => {
@@ -7961,13 +9132,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join4(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join5(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 += join4(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join5(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) {
@@ -8060,42 +9231,42 @@ var require_src2 = __commonJS((exports, module) => {
 });
 
 // src/lib/jsonc.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 function detectJsoncFile(configDir, baseName) {
   const jsoncPath = `${configDir}/${baseName}.jsonc`;
   const jsonPath = `${configDir}/${baseName}.json`;
-  if (existsSync3(jsoncPath)) {
+  if (existsSync4(jsoncPath)) {
     return { path: jsoncPath, format: "jsonc" };
   }
-  if (existsSync3(jsonPath)) {
+  if (existsSync4(jsonPath)) {
     return { path: jsonPath, format: "json" };
   }
   return { path: jsonPath, format: "none" };
 }
 function readJsoncFile(path) {
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     return { value: null };
   }
   try {
     const raw = readFileSync(path, "utf-8");
     const value = import_comment_json.parse(raw);
     return { value };
-  } catch (error) {
+  } catch (error2) {
     return {
       value: null,
-      error: error instanceof Error ? error.message : String(error)
+      error: error2 instanceof Error ? error2.message : String(error2)
     };
   }
 }
 function writeJsoncFile(path, value, format = "json") {
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync2(dirname(path), { recursive: true });
   const serialized = format === "jsonc" ? import_comment_json.stringify(value, null, 2) : JSON.stringify(value, null, 2);
   writeFileSync(path, `${serialized}
 `);
 }
 function ensureAftSchemaUrl(path, format) {
-  const existed = existsSync3(path);
+  const existed = existsSync4(path);
   if (!existed) {
     const writeFormat = format === "jsonc" ? "jsonc" : "json";
     writeJsoncFile(path, { $schema: AFT_SCHEMA_URL }, writeFormat);
@@ -8104,9 +9275,9 @@ function ensureAftSchemaUrl(path, format) {
       message: `created ${path} with $schema URL for editor autocomplete`
     };
   }
-  const { value, error } = readJsoncFile(path);
+  const { value, error: error2 } = readJsoncFile(path);
   if (!value) {
-    throw new Error(error ? `failed to parse ${path}: ${error}` : `failed to parse ${path}`);
+    throw new Error(error2 ? `failed to parse ${path}: ${error2}` : `failed to parse ${path}`);
   }
   const previous = value.$schema;
   if (previous === AFT_SCHEMA_URL) {
@@ -8148,26 +9319,52 @@ var init_self_version = () => {};
 
 // src/adapters/opencode.ts
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync2, rmSync, statSync as statSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname2, join as join4, parse, resolve } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync2, rmSync, statSync as statSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname2, join as join5, parse, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 function getOpenCodeConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
     return resolve(envDir);
-  const xdg = process.env.XDG_CONFIG_HOME || join4(homedir3(), ".config");
-  return join4(xdg, "opencode");
+  const xdg = process.env.XDG_CONFIG_HOME || join5(homedir4(), ".config");
+  return join5(xdg, "opencode");
 }
 function getOpenCodeCacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
   if (xdg)
-    return join4(xdg, "opencode");
+    return join5(xdg, "opencode");
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join4(homedir3(), "AppData", "Local");
-    return join4(localAppData, "opencode");
+    const localAppData = process.env.LOCALAPPDATA ?? join5(homedir4(), "AppData", "Local");
+    return join5(localAppData, "opencode");
+  }
+  return join5(homedir4(), ".cache", "opencode");
+}
+function hasOpenCodeCli() {
+  try {
+    execSync2("opencode --version", { stdio: "ignore", timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function openCodeDesktopAppExists() {
+  const candidates = [];
+  if (process.platform === "darwin") {
+    candidates.push("/Applications/OpenCode.app", "/Applications/OpenCode Beta.app", join5(homedir4(), "Applications", "OpenCode.app"), join5(homedir4(), "Applications", "OpenCode Beta.app"));
+  } else if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA ?? join5(homedir4(), "AppData", "Local");
+    candidates.push(join5(localAppData, "Programs", "opencode"), join5(localAppData, "opencode"));
+  } else {
+    candidates.push("/opt/OpenCode", "/usr/lib/opencode", join5(homedir4(), ".local", "share", "applications", "opencode.desktop"));
   }
-  return join4(homedir3(), ".cache", "opencode");
+  return candidates.some((p) => {
+    try {
+      return existsSync5(p);
+    } catch {
+      return false;
+    }
+  });
 }
 function pathFromEntry(entry) {
   if (entry.startsWith("file://")) {
@@ -8186,13 +9383,13 @@ function pathPointsToOurPlugin(entry) {
   if (!fsPath)
     return false;
   try {
-    if (!existsSync4(fsPath))
+    if (!existsSync5(fsPath))
       return false;
     let searchDir = statSync2(fsPath).isDirectory() ? fsPath : dirname2(fsPath);
     let pkgJsonPath = null;
     while (true) {
-      const candidate = join4(searchDir, "package.json");
-      if (existsSync4(candidate)) {
+      const candidate = join5(searchDir, "package.json");
+      if (existsSync5(candidate)) {
         pkgJsonPath = candidate;
         break;
       }
@@ -8223,16 +9420,19 @@ class OpenCodeAdapter {
   pluginPackageName = PLUGIN_NAME;
   pluginEntryWithVersion = PLUGIN_ENTRY;
   isInstalled() {
-    try {
-      execSync2("opencode --version", { stdio: "ignore" });
+    if (existsSync5(getOpenCodeConfigDir()))
       return true;
-    } catch {
-      return false;
-    }
+    if (openCodeDesktopAppExists())
+      return true;
+    return hasOpenCodeCli();
   }
   getHostVersion() {
     try {
-      return execSync2("opencode --version", { encoding: "utf-8", stdio: "pipe" }).trim();
+      return execSync2("opencode --version", {
+        encoding: "utf-8",
+        stdio: "pipe",
+        timeout: 5000
+      }).trim();
     } catch {
       return null;
     }
@@ -8271,12 +9471,12 @@ class OpenCodeAdapter {
         configPath
       };
     }
-    const { value, error } = readJsoncFile(configPath);
-    if (error || !value) {
+    const { value, error: error2 } = readJsoncFile(configPath);
+    if (error2 || !value) {
       return {
         ok: false,
         action: "error",
-        message: `Could not parse ${configPath}: ${error ?? "unknown error"}`,
+        message: `Could not parse ${configPath}: ${error2 ?? "unknown error"}`,
         configPath
       };
     }
@@ -8301,11 +9501,11 @@ class OpenCodeAdapter {
     };
   }
   getPluginCacheInfo() {
-    const path = join4(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY);
+    const path = join5(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY);
     let cached;
     try {
-      const installedPkgPath = join4(path, "node_modules", "@cortexkit", "aft-opencode", "package.json");
-      if (existsSync4(installedPkgPath)) {
+      const installedPkgPath = join5(path, "node_modules", "@cortexkit", "aft-opencode", "package.json");
+      if (existsSync5(installedPkgPath)) {
         const pkg = JSON.parse(readFileSync2(installedPkgPath, "utf-8"));
         cached = typeof pkg.version === "string" ? pkg.version : undefined;
       }
@@ -8316,7 +9516,7 @@ class OpenCodeAdapter {
       path,
       cached,
       latest: getSelfVersion(),
-      exists: existsSync4(path)
+      exists: existsSync5(path)
     };
   }
   getStorageDir() {
@@ -8349,13 +9549,13 @@ class OpenCodeAdapter {
         cached: info.cached,
         latest: info.latest
       };
-    } catch (error) {
+    } catch (error2) {
       return {
         action: "error",
         path: info.path,
         cached: info.cached,
         latest: info.latest,
-        error: error instanceof Error ? error.message : String(error)
+        error: error2 instanceof Error ? error2.message : String(error2)
       };
     }
   }
@@ -8365,11 +9565,11 @@ class OpenCodeAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join4(storage, "index")),
-      semantic: dirSize(join4(storage, "semantic")),
-      backups: dirSize(join4(storage, "backups")),
-      url_cache: dirSize(join4(storage, "url_cache")),
-      onnxruntime: dirSize(join4(storage, "onnxruntime"))
+      index: dirSize(join5(storage, "index")),
+      semantic: dirSize(join5(storage, "semantic")),
+      backups: dirSize(join5(storage, "backups")),
+      url_cache: dirSize(join5(storage, "url_cache")),
+      onnxruntime: dirSize(join5(storage, "onnxruntime"))
     };
   }
 }
@@ -8377,24 +9577,24 @@ var PLUGIN_NAME = "@cortexkit/aft-opencode", PLUGIN_ENTRY;
 var init_opencode = __esm(() => {
   init_fs_util();
   init_jsonc();
-  init_paths();
+  init_paths2();
   init_self_version();
   PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 });
 
 // src/adapters/pi.ts
 import { execSync as execSync3, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join6 } from "node:path";
 function getPiAgentDir() {
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
-  const home = envHome && envHome.length > 0 ? envHome : homedir4();
-  return join5(home, ".pi", "agent");
+  const home = envHome && envHome.length > 0 ? envHome : homedir5();
+  return join6(home, ".pi", "agent");
 }
 function readPiExtensionIndex() {
-  const settingsPath = join5(getPiAgentDir(), "settings.json");
-  if (existsSync5(settingsPath)) {
+  const settingsPath = join6(getPiAgentDir(), "settings.json");
+  if (existsSync6(settingsPath)) {
     try {
       const raw = readFileSync3(settingsPath, "utf-8");
       const trimmed = raw.replace(/^\uFEFF/, "");
@@ -8407,13 +9607,13 @@ function readPiExtensionIndex() {
     } catch {}
   }
   const candidates = [
-    join5(getPiAgentDir(), "extensions.json"),
-    join5(getPiAgentDir(), "extensions.jsonc"),
-    join5(getPiAgentDir(), "config.json"),
-    join5(getPiAgentDir(), "config.jsonc")
+    join6(getPiAgentDir(), "extensions.json"),
+    join6(getPiAgentDir(), "extensions.jsonc"),
+    join6(getPiAgentDir(), "config.json"),
+    join6(getPiAgentDir(), "config.jsonc")
   ];
   for (const path of candidates) {
-    if (!existsSync5(path))
+    if (!existsSync6(path))
       continue;
     try {
       const { value } = readJsoncFile(path);
@@ -8446,15 +9646,15 @@ function piEntryMatchesAft(entry) {
   } else if (entry.startsWith("/")) {
     resolved = entry;
   } else if (entry.length > 0) {
-    resolved = join5(getPiAgentDir(), entry);
+    resolved = join6(getPiAgentDir(), entry);
   }
   if (!resolved)
     return false;
   try {
-    if (!existsSync5(resolved))
+    if (!existsSync6(resolved))
       return false;
-    const pkgPath = join5(resolved, "package.json");
-    if (!existsSync5(pkgPath))
+    const pkgPath = join6(resolved, "package.json");
+    if (!existsSync6(pkgPath))
       return false;
     const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
     return pkg.name === PLUGIN_NAME2;
@@ -8474,7 +9674,7 @@ class PiAdapter {
   pluginEntryWithVersion = PLUGIN_ENTRY2;
   isInstalled() {
     try {
-      execSync3("pi --version", { stdio: "ignore" });
+      execSync3("pi --version", { stdio: "ignore", timeout: 5000 });
       return true;
     } catch {
       return false;
@@ -8484,7 +9684,8 @@ class PiAdapter {
     try {
       const result = spawnSync2("pi", ["--version"], {
         stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8"
+        encoding: "utf-8",
+        timeout: 5000
       });
       if (result.status !== 0)
         return null;
@@ -8503,7 +9704,7 @@ class PiAdapter {
     const aft = detectJsoncFile(configDir, "aft");
     return {
       configDir,
-      harnessConfig: index.path ?? join5(configDir, "extensions.json"),
+      harnessConfig: index.path ?? join6(configDir, "extensions.json"),
       harnessConfigFormat: index.path ? "json" : "none",
       aftConfig: aft.path,
       aftConfigFormat: aft.format
@@ -8537,22 +9738,22 @@ class PiAdapter {
         message: `Installed ${PLUGIN_ENTRY2} via \`pi install\``,
         configPath: this.detectConfigPaths().harnessConfig
       };
-    } catch (error) {
+    } catch (error2) {
       return {
         ok: false,
         action: "error",
-        message: `Failed to run \`pi install ${PLUGIN_ENTRY2}\`: ${error instanceof Error ? error.message : String(error)}`,
+        message: `Failed to run \`pi install ${PLUGIN_ENTRY2}\`: ${error2 instanceof Error ? error2.message : String(error2)}`,
         configPath: this.detectConfigPaths().harnessConfig
       };
     }
   }
   getPluginCacheInfo() {
     const candidates = [
-      join5(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join5(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
+      join6(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
+      join6(getPiAgentDir(), "extensions", "node_modules", "@cortexkit", "aft-pi", "package.json")
     ];
     for (const candidate of candidates) {
-      if (!existsSync5(candidate))
+      if (!existsSync6(candidate))
         continue;
       try {
         const pkg = JSON.parse(readFileSync3(candidate, "utf-8"));
@@ -8566,7 +9767,7 @@ class PiAdapter {
       } catch {}
     }
     return {
-      path: join5(getPiAgentDir(), "extensions"),
+      path: join6(getPiAgentDir(), "extensions"),
       exists: false
     };
   }
@@ -8588,11 +9789,11 @@ class PiAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join5(storage, "index")),
-      semantic: dirSize(join5(storage, "semantic")),
-      backups: dirSize(join5(storage, "backups")),
-      url_cache: dirSize(join5(storage, "url_cache")),
-      onnxruntime: dirSize(join5(storage, "onnxruntime"))
+      index: dirSize(join6(storage, "index")),
+      semantic: dirSize(join6(storage, "semantic")),
+      backups: dirSize(join6(storage, "backups")),
+      url_cache: dirSize(join6(storage, "url_cache")),
+      onnxruntime: dirSize(join6(storage, "onnxruntime"))
     };
   }
 }
@@ -8600,7 +9801,7 @@ var PLUGIN_NAME2 = "@cortexkit/aft-pi", PLUGIN_ENTRY2;
 var init_pi = __esm(() => {
   init_fs_util();
   init_jsonc();
-  init_paths();
+  init_paths2();
   PLUGIN_ENTRY2 = `npm:${PLUGIN_NAME2}`;
 });
 
@@ -8778,7 +9979,7 @@ var ANSI_RE, CONTROL_RE, TAB_RE, EMOJI_RE, LATIN_RE, MODIFIER_RE, NO_TRUNCATION,
     ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
   };
 }, dist_default;
-var init_dist = __esm(() => {
+var init_dist2 = __esm(() => {
   init_utils();
   ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/y;
   CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
@@ -8794,8 +9995,8 @@ var init_dist = __esm(() => {
 var NO_TRUNCATION2, fastStringWidth = (input, options = {}) => {
   return dist_default(input, NO_TRUNCATION2, options).width;
 }, dist_default2;
-var init_dist2 = __esm(() => {
-  init_dist();
+var init_dist3 = __esm(() => {
+  init_dist2();
   NO_TRUNCATION2 = {
     limit: Infinity,
     ellipsis: "",
@@ -8998,7 +10199,7 @@ var ESC = "\x1B", CSI = "›", END_CODE = 39, ANSI_ESCAPE_BELL = "\x07", ANSI_CSI
   return returnValue;
 }, CRLF_OR_LF;
 var init_main = __esm(() => {
-  init_dist2();
+  init_dist3();
   ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
   GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
   CRLF_OR_LF = /\r?\n/;
@@ -9278,7 +10479,7 @@ var import_sisteransi, E, G, u, Y, C, O = (r) => ("columns" in r) && typeof r.co
     }
   }
 }, H, Q, X, et, st, it, nt, at;
-var init_dist3 = __esm(() => {
+var init_dist4 = __esm(() => {
   init_main();
   import_sisteransi = __toESM(require_src3(), 1);
   E = ["up", "down", "left", "right", "space", "enter", "cancel"];
@@ -9900,11 +11101,11 @@ ${c2}
     }
   }
 } }).prompt();
-var init_dist4 = __esm(() => {
-  init_dist3();
-  init_dist3();
+var init_dist5 = __esm(() => {
+  init_dist4();
+  init_dist4();
   init_main();
-  init_dist2();
+  init_dist3();
   import_sisteransi2 = __toESM(require_src3(), 1);
   ee = Ze();
   _e = w2("◆", "*");
@@ -10014,7 +11215,7 @@ async function text(message, options = {}) {
   return result;
 }
 var init_prompts = __esm(() => {
-  init_dist4();
+  init_dist5();
 });
 
 // src/lib/harness-select.ts
@@ -10162,8 +11363,8 @@ async function runSetup(argv) {
       if (schemaResult.action === "added" || schemaResult.action === "updated") {
         O2.success(`${adapter.displayName}: ${schemaResult.message}`);
       }
-    } catch (error) {
-      O2.warn(`${adapter.displayName}: could not set $schema on aft.jsonc: ${error instanceof Error ? error.message : String(error)}`);
+    } catch (error2) {
+      O2.warn(`${adapter.displayName}: could not set $schema on aft.jsonc: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
     printNextSteps(adapter);
   }
@@ -10198,7 +11399,7 @@ var init_setup = __esm(() => {
 });
 
 // src/lib/aft-bridge.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 function isResponseForRequest(parsed, expectedIds) {
   if (!parsed || typeof parsed !== "object")
     return false;
@@ -10210,7 +11411,7 @@ function isResponseForRequest(parsed, expectedIds) {
 }
 async function sendAftRequests(binaryPath, requests) {
   return new Promise((resolve2, reject) => {
-    const child = spawn(binaryPath, [], {
+    const child = spawn2(binaryPath, [], {
       stdio: ["pipe", "pipe", "pipe"]
     });
     const responses = [];
@@ -10268,8 +11469,8 @@ async function sendAftRequests(binaryPath, requests) {
     child.stderr.on("data", (chunk) => {
       stderr += chunk;
     });
-    child.on("error", (error) => {
-      finish(() => reject(error));
+    child.on("error", (error2) => {
+      finish(() => reject(error2));
     });
     child.on("close", (code) => {
       if (settled)
@@ -10321,20 +11522,20 @@ __export(exports_lsp, {
   printLspDoctorHelp: () => printLspDoctorHelp,
   findProjectRootForFile: () => findProjectRootForFile
 });
-import { existsSync as existsSync6, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
-import { dirname as dirname3, join as join6, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
+import { dirname as dirname3, join as join7, resolve as resolve2 } from "node:path";
 function findProjectRootForFile(filePath, fallbackCwd = process.cwd()) {
   const resolvedFile = resolve2(fallbackCwd, filePath);
   let dir = dirname3(resolvedFile);
   try {
-    if (existsSync6(resolvedFile) && statSync3(resolvedFile).isDirectory()) {
+    if (existsSync7(resolvedFile) && statSync3(resolvedFile).isDirectory()) {
       dir = resolvedFile;
     }
   } catch {
     dir = dirname3(resolvedFile);
   }
   while (true) {
-    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync6(join6(dir, marker)))) {
+    if (PROJECT_ROOT_MARKERS.some((marker) => existsSync7(join7(dir, marker)))) {
       return dir;
     }
     const parent = dirname3(dir);
@@ -10364,8 +11565,8 @@ async function runLspDoctor(options) {
     O2.error("No harness selected.");
     return 1;
   }
-  const findBinary = options.findBinary ?? findAftBinary;
-  const binary = findBinary(getSelfVersion());
+  const findBinary2 = options.findBinary ?? findAftBinary;
+  const binary = findBinary2(getSelfVersion());
   if (!binary) {
     O2.error("Could not find the aft binary in the cache, platform package, PATH, or ~/.cargo/bin.");
     return 1;
@@ -10472,11 +11673,11 @@ function buildConfigureParams(adapter, projectRoot) {
 }
 function readProjectConfig(kind, projectRoot) {
   const dir = kind === "pi" ? ".pi" : ".opencode";
-  const jsonc = join6(projectRoot, dir, "aft.jsonc");
-  const json = join6(projectRoot, dir, "aft.json");
-  if (existsSync6(jsonc))
+  const jsonc = join7(projectRoot, dir, "aft.jsonc");
+  const json = join7(projectRoot, dir, "aft.json");
+  if (existsSync7(jsonc))
     return readJsoncFile(jsonc).value ?? {};
-  if (existsSync6(json))
+  if (existsSync7(json))
     return readJsoncFile(json).value ?? {};
   return {};
 }
@@ -10539,18 +11740,18 @@ function resolveCustomServers(servers) {
 function inferLspPathsExtra(_lsp) {
   const paths = new Set;
   for (const entry of childDirs(getAftLspPackagesDir())) {
-    paths.add(join6(entry, "node_modules", ".bin"));
+    paths.add(join7(entry, "node_modules", ".bin"));
   }
   for (const entry of childDirs(getAftLspBinariesDir())) {
-    paths.add(join6(entry, "bin"));
+    paths.add(join7(entry, "bin"));
   }
   return [...paths];
 }
 function childDirs(path) {
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return [];
   try {
-    return readdirSync2(path).map((entry) => join6(path, entry)).filter((entry) => {
+    return readdirSync2(path).map((entry) => join7(path, entry)).filter((entry) => {
       try {
         return statSync3(entry).isDirectory();
       } catch {
@@ -10600,7 +11801,7 @@ var init_lsp = __esm(async () => {
   init_aft_bridge();
   init_harness_select();
   init_jsonc();
-  init_paths();
+  init_paths2();
   init_prompts();
   init_self_version();
   await init_binary_probe();
@@ -10630,8 +11831,8 @@ __export(exports_doctor_filters, {
   renderFilterList: () => renderFilterList,
   printDoctorFiltersHelp: () => printDoctorFiltersHelp
 });
-import { existsSync as existsSync7 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { existsSync as existsSync8 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
 import { relative, resolve as resolve3 } from "node:path";
 function printDoctorFiltersHelp() {
   console.log("Usage: aft doctor filters [--show <name>] [trust|untrust]");
@@ -10661,8 +11862,8 @@ async function runDoctorFilters(options) {
     O2.error("No harness selected.");
     return 1;
   }
-  const findBinary = options.findBinary ?? findAftBinary;
-  const binary = findBinary(getSelfVersion());
+  const findBinary2 = options.findBinary ?? findAftBinary;
+  const binary = findBinary2(getSelfVersion());
   if (!binary) {
     O2.error("Could not find the aft binary in the cache, platform package, PATH, or ~/.cargo/bin.");
     return 1;
@@ -10673,7 +11874,7 @@ async function runDoctorFilters(options) {
     O2.error(list.message ?? list.code ?? "list_filters failed");
     return 1;
   }
-  list.project_dir_exists = list.project_dir ? existsSync7(list.project_dir) : false;
+  list.project_dir_exists = list.project_dir ? existsSync8(list.project_dir) : false;
   if (mode.kind === "list") {
     console.log(renderFilterList(list, projectRoot));
     return 0;
@@ -10849,7 +12050,7 @@ function truncate(value) {
   return value.length <= 80 ? value : `${value.slice(0, 77)}…`;
 }
 function formatHome(path) {
-  const home = homedir5();
+  const home = homedir6();
   return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
 }
 function formatProjectPath(path, projectRoot) {
@@ -10872,11 +12073,11 @@ var init_doctor_filters = __esm(async () => {
 });
 
 // src/lib/binary-cache.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
+import { join as join8 } from "node:path";
 function getBinaryCacheInfo(activeVersion) {
   const path = getAftBinaryCacheDir();
-  if (!existsSync8(path)) {
+  if (!existsSync9(path)) {
     return {
       versions: [],
       activeVersion: null,
@@ -10886,7 +12087,7 @@ function getBinaryCacheInfo(activeVersion) {
   }
   const versions = readdirSync3(path).filter((entry) => {
     try {
-      return statSync4(join7(path, entry)).isDirectory();
+      return statSync4(join8(path, entry)).isDirectory();
     } catch {
       return false;
     }
@@ -10902,14 +12103,14 @@ function getBinaryCacheInfo(activeVersion) {
 }
 var init_binary_cache = __esm(() => {
   init_fs_util();
-  init_paths();
+  init_paths2();
 });
 
 // src/lib/lsp-cache.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, rmSync as rmSync2, statSync as statSync5 } from "node:fs";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync10, readdirSync as readdirSync4, rmSync as rmSync2, statSync as statSync5 } from "node:fs";
+import { join as join9 } from "node:path";
 function inspectDir(path) {
-  if (!existsSync9(path)) {
+  if (!existsSync10(path)) {
     return { entries: [], totalSize: 0 };
   }
   const entries = [];
@@ -10921,7 +12122,7 @@ function inspectDir(path) {
     return { entries: [], totalSize: 0 };
   }
   for (const name of names) {
-    const full = join8(path, name);
+    const full = join9(path, name);
     try {
       if (!statSync5(full).isDirectory())
         continue;
@@ -10975,12 +12176,12 @@ function clearLspCaches() {
 }
 var init_lsp_cache = __esm(() => {
   init_fs_util();
-  init_paths();
+  init_paths2();
 });
 
 // src/lib/onnx.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5, readlinkSync, realpathSync, statSync as statSync6 } from "node:fs";
-import { basename, isAbsolute, join as join9, resolve as resolve4, win32 } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync5, readlinkSync, realpathSync as realpathSync2, statSync as statSync6 } from "node:fs";
+import { basename, isAbsolute, join as join10, resolve as resolve4, win32 } from "node:path";
 function getOnnxLibraryName() {
   if (process.platform === "darwin")
     return "libonnxruntime.dylib";
@@ -10988,7 +12189,7 @@ function getOnnxLibraryName() {
     return "onnxruntime.dll";
   return "libonnxruntime.so";
 }
-function getManualInstallHint() {
+function getManualInstallHint2() {
   const p2 = process.platform;
   const a = process.arch;
   if (p2 === "darwin") {
@@ -11043,13 +12244,13 @@ function findSystemOnnxRuntime() {
     searchPaths.push(...pathEntriesForPlatform());
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join9(programFiles, "onnxruntime", "lib"), join9(programFiles, "Microsoft ONNX Runtime", "lib"), join9(programFiles, "Microsoft Machine Learning", "lib"), join9(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join10(programFiles, "onnxruntime", "lib"), join10(programFiles, "Microsoft ONNX Runtime", "lib"), join10(programFiles, "Microsoft Machine Learning", "lib"), join10(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join9(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync10(nugetPackageDir))
+      const nugetPackageDir = join10(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync11(nugetPackageDir))
         return nugetPaths;
       try {
         for (const entry of readdirSync5(nugetPackageDir, { withFileTypes: true })) {
@@ -11057,7 +12258,7 @@ function findSystemOnnxRuntime() {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join9(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join9(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join10(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join10(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch {}
       return nugetPaths;
@@ -11087,12 +12288,12 @@ function findSystemOnnxRuntime() {
   return unknownVersionPaths[0] ?? null;
 }
 function findCachedOnnxRuntime(storageDir) {
-  const ortDir = join9(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
+  const ortDir = join10(storageDir, "onnxruntime", ONNX_RUNTIME_VERSION);
   const libName = getOnnxLibraryName();
-  if (existsSync10(join9(ortDir, libName)))
+  if (existsSync11(join10(ortDir, libName)))
     return ortDir;
-  const libSubdir = join9(ortDir, "lib");
-  if (existsSync10(join9(libSubdir, libName)))
+  const libSubdir = join10(ortDir, "lib");
+  if (existsSync11(join10(libSubdir, libName)))
     return libSubdir;
   return null;
 }
@@ -11113,7 +12314,7 @@ function parseOrtVersionFromDirectoryPath(value) {
   return null;
 }
 function detectOrtVersion(libDir) {
-  if (!existsSync10(libDir))
+  if (!existsSync11(libDir))
     return null;
   const libName = getOnnxLibraryName();
   try {
@@ -11128,10 +12329,10 @@ function detectOrtVersion(libDir) {
       if (version)
         return version;
     }
-    const base = join9(libDir, libName);
-    if (existsSync10(base)) {
+    const base = join10(libDir, libName);
+    if (existsSync11(base)) {
       try {
-        const real = realpathSync(base);
+        const real = realpathSync2(base);
         const version = parseOrtVersionFromPath(real) ?? parseOrtVersionFromDirectoryPath(real);
         if (version)
           return version;
@@ -11160,14 +12361,14 @@ var ONNX_RUNTIME_VERSION = "1.24.4", INVALID_ORT_VERSION = "<invalid>", REQUIRED
 var init_onnx = () => {};
 
 // src/lib/sanitize.ts
-import { realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir6, userInfo } from "node:os";
+import { realpathSync as realpathSync3 } from "node:fs";
+import { homedir as homedir7, userInfo } from "node:os";
 function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function safeRealpath(p2) {
   try {
-    return realpathSync2(p2);
+    return realpathSync3(p2);
   } catch {
     return null;
   }
@@ -11192,7 +12393,7 @@ function redactSecrets(content) {
 }
 function sanitizeContent(content) {
   const username = userInfo().username;
-  const home = homedir6();
+  const home = homedir7();
   let sanitized = redactSecrets(content);
   const cwd = process.cwd();
   for (const candidate of new Set([cwd, safeRealpath(cwd)])) {
@@ -11239,11 +12440,11 @@ var init_sanitize = __esm(() => {
 // src/lib/diagnostics.ts
 import {
   accessSync,
-  closeSync,
+  closeSync as closeSync2,
   constants,
-  existsSync as existsSync11,
-  openSync,
-  readSync,
+  existsSync as existsSync12,
+  openSync as openSync2,
+  readSync as readSync2,
   statSync as statSync7
 } from "node:fs";
 async function collectDiagnostics(adapters) {
@@ -11273,7 +12474,7 @@ async function diagnoseHarness(adapter) {
   const logPath = adapter.getLogFile();
   const pluginCache = adapter.getPluginCacheInfo();
   const storageAccessible = (() => {
-    if (!existsSync11(storage))
+    if (!existsSync12(storage))
       return false;
     try {
       accessSync(storage, constants.R_OK | constants.W_OK);
@@ -11296,14 +12497,14 @@ async function diagnoseHarness(adapter) {
     pluginRegistered: adapter.hasPluginEntry(),
     configPaths,
     aftConfig: {
-      exists: existsSync11(configPaths.aftConfig),
+      exists: existsSync12(configPaths.aftConfig),
       ...aftConfigRead.error ? { parseError: aftConfigRead.error } : {},
       flags: aftFlags
     },
     pluginCache,
     storageDir: {
       path: storage,
-      exists: existsSync11(storage),
+      exists: existsSync12(storage),
       accessible: storageAccessible,
       sizesByKey: describeStorage
     },
@@ -11316,13 +12517,13 @@ async function diagnoseHarness(adapter) {
       cachedVersion,
       cachedCompatible: cachedVersion ? isOrtVersionCompatible(cachedVersion) : null,
       platform: `${process.platform}-${process.arch}`,
-      installHint: getManualInstallHint(),
+      installHint: getManualInstallHint2(),
       requirement: `>=${REQUIRED_ORT_MAJOR}.${REQUIRED_ORT_MIN_MINOR}`
     },
     logFile: {
       path: logPath,
-      exists: existsSync11(logPath),
-      sizeKb: existsSync11(logPath) ? Math.round(statSync7(logPath).size / 1024) : 0
+      exists: existsSync12(logPath),
+      sizeKb: existsSync12(logPath) ? Math.round(statSync7(logPath).size / 1024) : 0
     }
   };
 }
@@ -11516,7 +12717,7 @@ function formatDiagnosticIssuesSection(report) {
   return lines;
 }
 function tailLogFile(path, lines) {
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return "";
   if (lines <= 0)
     return "";
@@ -11524,7 +12725,7 @@ function tailLogFile(path, lines) {
   let fd = null;
   try {
     const size = statSync7(path).size;
-    fd = openSync(path, "r");
+    fd = openSync2(path, "r");
     const chunks = [];
     let position = size;
     let newlineCount = 0;
@@ -11532,7 +12733,7 @@ function tailLogFile(path, lines) {
       const readLength = Math.min(chunkSize, position);
       position -= readLength;
       const buffer = Buffer.allocUnsafe(readLength);
-      const bytesRead = readSync(fd, buffer, 0, readLength, position);
+      const bytesRead = readSync2(fd, buffer, 0, readLength, position);
       const chunk = bytesRead === readLength ? buffer : buffer.subarray(0, bytesRead);
       chunks.unshift(chunk);
       for (let i = chunk.length - 1;i >= 0; i -= 1) {
@@ -11547,7 +12748,7 @@ function tailLogFile(path, lines) {
   } finally {
     if (fd !== null) {
       try {
-        closeSync(fd);
+        closeSync2(fd);
       } catch {}
     }
   }
@@ -11643,7 +12844,7 @@ function capBodyToGithubLimit(body, maxBytes = MAX_GITHUB_BODY_BYTES) {
   const logBlockStart = headingEol + 1;
   const logBlockEnd = nextSectionIdx === -1 ? body.length : nextSectionIdx;
   const head = body.slice(0, logBlockStart);
-  const log = body.slice(logBlockStart, logBlockEnd);
+  const log2 = body.slice(logBlockStart, logBlockEnd);
   const tail = body.slice(logBlockEnd);
   const overheadBytes = Buffer.byteLength(head, "utf8") + Buffer.byteLength(tail, "utf8");
   const truncationMarker = `[truncated for GitHub 64KB limit — older log lines dropped]
@@ -11653,7 +12854,7 @@ function capBodyToGithubLimit(body, maxBytes = MAX_GITHUB_BODY_BYTES) {
   if (logBudget <= 0) {
     return `${head}${truncationMarker}${tail}`;
   }
-  const lines = log.split(`
+  const lines = log2.split(`
 `);
   let keepLines = lines;
   let kept = keepLines.join(`
@@ -11702,8 +12903,8 @@ var init_issue_body = __esm(() => {
 });
 
 // src/lib/onnx-fix.ts
-import { existsSync as existsSync12, rmSync as rmSync3 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync13, rmSync as rmSync3 } from "node:fs";
+import { join as join11 } from "node:path";
 function findOnnxFixCandidates(report) {
   const candidates = [];
   for (const harness of report.harnesses) {
@@ -11711,7 +12912,7 @@ function findOnnxFixCandidates(report) {
       continue;
     if (!harness.storageDir.exists)
       continue;
-    const storageOnnxDir = join10(harness.storageDir.path, "onnxruntime");
+    const storageOnnxDir = join11(harness.storageDir.path, "onnxruntime");
     const systemTooOld = harness.onnxRuntime.systemPath !== null && harness.onnxRuntime.systemCompatible === false;
     const cachedTooOld = harness.onnxRuntime.cachedPath !== null && harness.onnxRuntime.cachedCompatible === false;
     const hasCompatibleCached = harness.onnxRuntime.cachedCompatible === true;
@@ -11720,7 +12921,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `cached ONNX Runtime at ${harness.onnxRuntime.cachedPath} is v${harness.onnxRuntime.cachedVersion}, but AFT requires ${harness.onnxRuntime.requirement}. Clearing forces a fresh download on next start.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync12(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync13(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
       continue;
     }
@@ -11729,7 +12930,7 @@ function findOnnxFixCandidates(report) {
         harness,
         reason: `system ONNX Runtime at ${harness.onnxRuntime.systemPath} is v${harness.onnxRuntime.systemVersion}, but AFT requires ${harness.onnxRuntime.requirement}, and no AFT-managed install is present. AFT v0.19.5+ skips incompatible system installs and auto-downloads v1.24 on next start; clearing any stale state here ensures a clean slate.`,
         storageOnnxDir,
-        storageOnnxBytes: existsSync12(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
+        storageOnnxBytes: existsSync13(storageOnnxDir) ? dirSize(storageOnnxDir) : 0
       });
     }
   }
@@ -11759,7 +12960,7 @@ async function runOnnxFix(adapters, report, options = {}) {
   const result = { cleared: 0, bytesReclaimed: 0, errors: [] };
   const rmFn = options.rmFn ?? rmSync3;
   for (const c2 of candidates) {
-    if (!existsSync12(c2.storageOnnxDir)) {
+    if (!existsSync13(c2.storageOnnxDir)) {
       O2.success(`${c2.harness.displayName}: no cached state to clear; restart your harness to trigger a fresh ONNX download`);
       continue;
     }
@@ -11785,10 +12986,10 @@ var init_onnx_fix = __esm(() => {
 });
 
 // src/lib/sessions.ts
-import { existsSync as existsSync13, readdirSync as readdirSync6, readFileSync as readFileSync4, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync14, readdirSync as readdirSync6, readFileSync as readFileSync4, statSync as statSync8 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { homedir as homedir7 } from "node:os";
-import { basename as basename2, join as join11 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { basename as basename2, join as join12 } from "node:path";
 function listRecentSessions(adapter) {
   try {
     if (adapter.kind === "opencode")
@@ -11817,8 +13018,8 @@ function mapOpenCodeSessionRows(rows) {
   }).filter((session) => session !== null).sort((a, b) => b.lastActivity - a.lastActivity).slice(0, MAX_RECENT_SESSIONS);
 }
 function listRecentOpenCodeSessions() {
-  const dbPath = join11(getXdgDataHome(), "opencode", "opencode.db");
-  if (!existsSync13(dbPath))
+  const dbPath = join12(getXdgDataHome(), "opencode", "opencode.db");
+  if (!existsSync14(dbPath))
     return [];
   let db = null;
   try {
@@ -11837,18 +13038,18 @@ function listRecentOpenCodeSessions() {
 }
 function getXdgDataHome() {
   const xdgDataHome = process.env.XDG_DATA_HOME;
-  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join11(homedir7(), ".local", "share");
+  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join12(homedir8(), ".local", "share");
 }
 function listRecentPiSessions() {
-  return listPiSessionsFromDir(join11(getHomeDir(), ".pi", "agent", "sessions"));
+  return listPiSessionsFromDir(join12(getHomeDir(), ".pi", "agent", "sessions"));
 }
 function getHomeDir() {
   const envHome = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
-  return envHome && envHome.length > 0 ? envHome : homedir7();
+  return envHome && envHome.length > 0 ? envHome : homedir8();
 }
 function listPiSessionsFromDir(sessionsDir) {
   try {
-    if (!existsSync13(sessionsDir))
+    if (!existsSync14(sessionsDir))
       return [];
     const files = collectJsonlFiles(sessionsDir).map((filePath) => {
       try {
@@ -11886,7 +13087,7 @@ function collectJsonlFiles(root) {
       continue;
     }
     for (const entry of entries) {
-      const path = join11(dir, entry.name);
+      const path = join12(dir, entry.name);
       if (entry.isDirectory()) {
         stack.push(path);
       } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
@@ -11984,18 +13185,18 @@ __export(exports_doctor, {
   DOCTOR_CLEAR_TARGET_OPTIONS: () => DOCTOR_CLEAR_TARGET_OPTIONS
 });
 import {
-  chmodSync,
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync2,
+  chmodSync as chmodSync2,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync3,
   mkdtempSync,
   readFileSync as readFileSync5,
-  realpathSync as realpathSync3,
+  realpathSync as realpathSync4,
   rmSync as rmSync4,
   statSync as statSync9,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function runDoctor(options) {
   if (options.issue) {
     return runIssueFlow(options.argv);
@@ -12149,7 +13350,7 @@ function clearOldBinaries() {
     errors: [],
     keptVersion: keepTag
   };
-  if (!existsSync14(info.path)) {
+  if (!existsSync15(info.path)) {
     O2.info(`Binary cache: nothing to clear at ${info.path}`);
     return result;
   }
@@ -12159,7 +13360,7 @@ function clearOldBinaries() {
     return result;
   }
   for (const version of stale) {
-    const dir = join12(info.path, version);
+    const dir = join13(info.path, version);
     let bytes = 0;
     try {
       bytes = statSync9(dir).isDirectory() ? dirSize(dir) : 0;
@@ -12211,9 +13412,9 @@ function applySchemaFixes(targets) {
         changed += 1;
         O2.success(`${target.adapter.displayName}: ${result.message}`);
       }
-    } catch (error) {
+    } catch (error2) {
       errors += 1;
-      O2.warn(`${target.adapter.displayName}: could not set $schema on ${target.aftConfig}: ${error instanceof Error ? error.message : String(error)}`);
+      O2.warn(`${target.adapter.displayName}: could not set $schema on ${target.aftConfig}: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
   return { changed, errors };
@@ -12343,8 +13544,8 @@ async function runFixFlow(argv) {
       O2.info("AFT binary not found. Downloading…");
       try {
         const bridgePackageName = "@cortexkit/aft-bridge";
-        const { ensureBinary } = await import(bridgePackageName);
-        const path = await ensureBinary(`v${report.cliVersion}`);
+        const { ensureBinary: ensureBinary2 } = await import(bridgePackageName);
+        const path = await ensureBinary2(`v${report.cliVersion}`);
         if (path) {
           O2.success(`AFT binary installed at ${path}`);
           binaryDownloaded = true;
@@ -12423,9 +13624,9 @@ function ensureStorageDirsForRegisteredPlugins(adapters) {
       if (!adapter.isInstalled() || !adapter.hasPluginEntry())
         continue;
       const storageDir = adapter.getStorageDir();
-      if (existsSync14(storageDir))
+      if (existsSync15(storageDir))
         continue;
-      mkdirSync2(storageDir, { recursive: true });
+      mkdirSync3(storageDir, { recursive: true });
       summary.created += 1;
       O2.success(`${adapter.displayName}: created AFT storage directory at ${storageDir}`);
     } catch (err) {
@@ -12526,14 +13727,14 @@ function deriveIssueTitleFromBody(body) {
 function writeIssueReviewFile(body) {
   let reviewDir = null;
   try {
-    reviewDir = mkdtempSync(join12(tmpdir2(), "aft-issue-"));
+    reviewDir = mkdtempSync(join13(tmpdir2(), "aft-issue-"));
     if (process.platform !== "win32") {
-      chmodSync(reviewDir, 448);
+      chmodSync2(reviewDir, 448);
     }
-    const outPath = join12(reviewDir, "issue.md");
+    const outPath = join13(reviewDir, "issue.md");
     writeFileSync2(outPath, `${body}
 `, { encoding: "utf8", mode: 384, flag: "wx" });
-    return { path: outPath, realPath: realpathSync3(outPath) };
+    return { path: outPath, realPath: realpathSync4(outPath) };
   } catch (err) {
     if (reviewDir) {
       try {
@@ -12546,7 +13747,7 @@ function writeIssueReviewFile(body) {
 }
 function readReviewedIssueFile(reviewFile) {
   try {
-    const realPath = realpathSync3(reviewFile.path);
+    const realPath = realpathSync4(reviewFile.path);
     if (realPath !== reviewFile.realPath) {
       O2.error(`Review file path changed before filing; refusing to read ${reviewFile.path}.`);
       return null;