@cortexkit/aft 0.34.0 → 0.35.1

package/dist/index.js

@@ -46,11 +46,1406 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
 
+// ../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 join2(process.env.AFT_CACHE_DIR, "bin");
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
+    const base2 = localAppData || join2(homedir2(), "AppData", "Local");
+    return join2(base2, "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 join2(process.env.AFT_CACHE_DIR, "lsp-packages");
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
+    const base2 = localAppData || join2(homedir2(), "AppData", "Local");
+    return join2(base2, "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 join2(process.env.AFT_CACHE_DIR, "lsp-binaries");
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
+    const base2 = localAppData || join2(homedir2(), "AppData", "Local");
+    return join2(base2, "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 || 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 || join2(homeDir(), "AppData", "Local");
+  }
+  return join2(homeDir(), ".local", "share");
+}
+function getCortexKitStorageRoot() {
+  return join2(dataHome(), "cortexkit", "aft");
+}
+function getTmpLogPath(filename) {
+  return join2(tmpdir(), filename);
+}
+var init_paths2 = () => {};
+
+// src/lib/binary-probe.ts
+import { execSync, spawnSync } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+async function loadPluginVersion() {
+  try {
+    const bridgePackageName = "@cortexkit/aft-bridge";
+    const bridge = await import(bridgePackageName);
+    if (typeof bridge.PLUGIN_VERSION === "string" && bridge.PLUGIN_VERSION.length > 0) {
+      return bridge.PLUGIN_VERSION;
+    }
+  } catch {}
+  const require2 = createRequire(import.meta.url);
+  for (const relPath of [
+    "../../../aft-bridge/package.json",
+    "../../package.json",
+    "../package.json"
+  ]) {
+    try {
+      const pkg = require2(relPath);
+      if (typeof pkg.version === "string" && pkg.version.length > 0)
+        return pkg.version;
+    } catch {}
+  }
+  return "unknown";
+}
+function parseVersionOutput(output) {
+  for (const line of output.split(/\r?\n/)) {
+    const match = line.trim().match(VERSION_LINE);
+    if (match?.[1])
+      return match[1];
+  }
+  return null;
+}
+function majorMinor(version) {
+  if (!version)
+    return null;
+  const match = version.trim().match(/^v?(\d+)\.(\d+)\.\d+(?:[-+][0-9A-Za-z.-]+)?$/);
+  if (!match)
+    return null;
+  return `${match[1]}.${match[2]}`;
+}
+function versionMatchesExpected(candidate, expectedVersion) {
+  const candidateMajorMinor = majorMinor(candidate);
+  const expectedMajorMinor = majorMinor(expectedVersion);
+  return candidateMajorMinor !== null && candidateMajorMinor === expectedMajorMinor;
+}
+function probeBinaryVersion(preferredVersion) {
+  return probeAftBinary(preferredVersion).version;
+}
+function probeAftBinary(preferredVersion) {
+  const expectedVersion = preferredVersion ?? PLUGIN_VERSION;
+  const expectedMajorMinor = majorMinor(expectedVersion);
+  const candidates = [];
+  for (const candidate of aftBinaryCandidates(preferredVersion)) {
+    try {
+      if (!existsSync2(candidate))
+        continue;
+      const result = spawnSync(candidate, ["--version"], {
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        timeout: 5000,
+        env: process.env
+      });
+      const output = `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim();
+      if (result.error || result.status !== 0) {
+        candidates.push({
+          path: candidate,
+          status: "error",
+          version: null,
+          ...output ? { output } : {},
+          error: result.error?.message ?? `exit status ${result.status ?? "unknown"}`
+        });
+        continue;
+      }
+      const version = parseVersionOutput(output);
+      if (!version) {
+        candidates.push({ path: candidate, status: "invalid", version: null, output });
+        continue;
+      }
+      if (!versionMatchesExpected(version, expectedVersion)) {
+        candidates.push({ path: candidate, status: "unmatched", version, output });
+        continue;
+      }
+      candidates.push({ path: candidate, status: "matched", version, output });
+      return { version, path: candidate, expectedVersion, expectedMajorMinor, candidates };
+    } catch (error2) {
+      candidates.push({
+        path: candidate,
+        status: "error",
+        version: null,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
+  }
+  return { version: null, path: null, expectedVersion, expectedMajorMinor, candidates };
+}
+function pushCandidate(candidates, candidate) {
+  if (!candidate)
+    return;
+  if (!candidates.includes(candidate))
+    candidates.push(candidate);
+}
+function firstExisting(candidates) {
+  for (const candidate of candidates) {
+    try {
+      if (!existsSync2(candidate))
+        continue;
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+function platformKey2(platform = process.platform, arch = process.arch) {
+  const table = {
+    darwin: { arm64: "darwin-arm64", x64: "darwin-x64" },
+    linux: { arm64: "linux-arm64", x64: "linux-x64" },
+    win32: { x64: "win32-x64" }
+  };
+  return table[platform]?.[arch] ?? null;
+}
+function aftBinaryCandidates(preferredVersion) {
+  const candidates = [];
+  if (preferredVersion) {
+    const tag = preferredVersion.startsWith("v") ? preferredVersion : `v${preferredVersion}`;
+    pushCandidate(candidates, join3(getAftBinaryCacheDir(), tag, getAftBinaryName()));
+  }
+  const key = platformKey2();
+  if (key) {
+    try {
+      const require2 = createRequire(import.meta.url);
+      pushCandidate(candidates, require2.resolve(`@cortexkit/aft-${key}/bin/${getAftBinaryName()}`));
+    } catch {}
+  }
+  try {
+    const lookup = process.platform === "win32" ? "where aft" : "which aft";
+    const resolved = execSync(lookup, {
+      stdio: "pipe",
+      encoding: "utf-8",
+      env: process.env
+    }).trim();
+    for (const line of resolved.split(/\r?\n/)) {
+      const candidate = line.trim();
+      if (candidate && isNativeExecutable(candidate)) {
+        pushCandidate(candidates, candidate);
+      }
+    }
+  } catch {}
+  pushCandidate(candidates, join3(homedir3(), ".cargo", "bin", getAftBinaryName()));
+  return candidates;
+}
+function findAftBinary(preferredVersion) {
+  return firstExisting(aftBinaryCandidates(preferredVersion));
+}
+var PLUGIN_VERSION, VERSION_LINE;
+var init_binary_probe = __esm(async () => {
+  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, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync as existsSync3, readdirSync, statSync } from "node:fs";
+import { join as join4 } from "node:path";
 function dirSize(path) {
-  if (!existsSync(path)) {
+  if (!existsSync3(path)) {
     return 0;
   }
   const stat = statSync(path);
@@ -62,7 +1457,7 @@ function dirSize(path) {
   }
   let total = 0;
   for (const entry of readdirSync(path)) {
-    total += dirSize(join(path, entry));
+    total += dirSize(join4(path, entry));
   }
   return total;
 }
@@ -4616,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;
@@ -7324,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];
@@ -7685,10 +9080,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join2 = (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 join2(comment, inside, gap);
+    return join5(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -7710,13 +9105,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join2(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 += join2(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) => {
@@ -7737,13 +9132,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join2(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 += join2(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) {
@@ -7836,42 +9231,42 @@ var require_src2 = __commonJS((exports, module) => {
 });
 
 // src/lib/jsonc.ts
-import { existsSync as existsSync2, 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 (existsSync2(jsoncPath)) {
+  if (existsSync4(jsoncPath)) {
     return { path: jsoncPath, format: "jsonc" };
   }
-  if (existsSync2(jsonPath)) {
+  if (existsSync4(jsonPath)) {
     return { path: jsonPath, format: "json" };
   }
   return { path: jsonPath, format: "none" };
 }
 function readJsoncFile(path) {
-  if (!existsSync2(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 = existsSync2(path);
+  const existed = existsSync4(path);
   if (!existed) {
     const writeFormat = format === "jsonc" ? "jsonc" : "json";
     writeJsoncFile(path, { $schema: AFT_SCHEMA_URL }, writeFormat);
@@ -7880,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) {
@@ -7906,73 +9301,10 @@ var init_jsonc = __esm(() => {
   import_comment_json = __toESM(require_src2(), 1);
 });
 
-// src/lib/paths.ts
-import { homedir, tmpdir } from "node:os";
-import { join as join2 } from "node:path";
-function getAftBinaryCacheDir() {
-  if (process.env.AFT_CACHE_DIR) {
-    return join2(process.env.AFT_CACHE_DIR, "bin");
-  }
-  if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join2(homedir(), "AppData", "Local");
-    return join2(base2, "aft", "bin");
-  }
-  const base = process.env.XDG_CACHE_HOME || join2(homedir(), ".cache");
-  return join2(base, "aft", "bin");
-}
-function getAftBinaryName() {
-  return process.platform === "win32" ? "aft.exe" : "aft";
-}
-function getAftLspPackagesDir() {
-  if (process.env.AFT_CACHE_DIR) {
-    return join2(process.env.AFT_CACHE_DIR, "lsp-packages");
-  }
-  if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join2(homedir(), "AppData", "Local");
-    return join2(base2, "aft", "lsp-packages");
-  }
-  const base = process.env.XDG_CACHE_HOME || join2(homedir(), ".cache");
-  return join2(base, "aft", "lsp-packages");
-}
-function getAftLspBinariesDir() {
-  if (process.env.AFT_CACHE_DIR) {
-    return join2(process.env.AFT_CACHE_DIR, "lsp-binaries");
-  }
-  if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join2(homedir(), "AppData", "Local");
-    return join2(base2, "aft", "lsp-binaries");
-  }
-  const base = process.env.XDG_CACHE_HOME || join2(homedir(), ".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();
-}
-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 || join2(homeDir(), "AppData", "Local");
-  }
-  return join2(homeDir(), ".local", "share");
-}
-function getCortexKitStorageRoot() {
-  return join2(dataHome(), "cortexkit", "aft");
-}
-function getTmpLogPath(filename) {
-  return join2(tmpdir(), filename);
-}
-var init_paths = () => {};
-
 // src/lib/self-version.ts
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 function getSelfVersion() {
-  const require2 = createRequire(import.meta.url);
+  const require2 = createRequire2(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
     try {
       const version = require2(relPath).version;
@@ -7986,27 +9318,53 @@ function getSelfVersion() {
 var init_self_version = () => {};
 
 // src/adapters/opencode.ts
-import { execSync } from "node:child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2, rmSync, statSync as statSync2 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join3, parse, resolve } from "node:path";
+import { execSync as execSync2 } from "node:child_process";
+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 || join3(homedir2(), ".config");
-  return join3(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 join3(xdg, "opencode");
+    return join5(xdg, "opencode");
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join3(homedir2(), "AppData", "Local");
-    return join3(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 join3(homedir2(), ".cache", "opencode");
+  return candidates.some((p) => {
+    try {
+      return existsSync5(p);
+    } catch {
+      return false;
+    }
+  });
 }
 function pathFromEntry(entry) {
   if (entry.startsWith("file://")) {
@@ -8025,13 +9383,13 @@ function pathPointsToOurPlugin(entry) {
   if (!fsPath)
     return false;
   try {
-    if (!existsSync3(fsPath))
+    if (!existsSync5(fsPath))
       return false;
     let searchDir = statSync2(fsPath).isDirectory() ? fsPath : dirname2(fsPath);
     let pkgJsonPath = null;
     while (true) {
-      const candidate = join3(searchDir, "package.json");
-      if (existsSync3(candidate)) {
+      const candidate = join5(searchDir, "package.json");
+      if (existsSync5(candidate)) {
         pkgJsonPath = candidate;
         break;
       }
@@ -8062,16 +9420,19 @@ class OpenCodeAdapter {
   pluginPackageName = PLUGIN_NAME;
   pluginEntryWithVersion = PLUGIN_ENTRY;
   isInstalled() {
-    try {
-      execSync("opencode --version", { stdio: "ignore" });
+    if (existsSync5(getOpenCodeConfigDir()))
       return true;
-    } catch {
-      return false;
-    }
+    if (openCodeDesktopAppExists())
+      return true;
+    return hasOpenCodeCli();
   }
   getHostVersion() {
     try {
-      return execSync("opencode --version", { encoding: "utf-8", stdio: "pipe" }).trim();
+      return execSync2("opencode --version", {
+        encoding: "utf-8",
+        stdio: "pipe",
+        timeout: 5000
+      }).trim();
     } catch {
       return null;
     }
@@ -8110,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
       };
     }
@@ -8140,11 +9501,11 @@ class OpenCodeAdapter {
     };
   }
   getPluginCacheInfo() {
-    const path = join3(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY);
+    const path = join5(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY);
     let cached;
     try {
-      const installedPkgPath = join3(path, "node_modules", "@cortexkit", "aft-opencode", "package.json");
-      if (existsSync3(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;
       }
@@ -8155,7 +9516,7 @@ class OpenCodeAdapter {
       path,
       cached,
       latest: getSelfVersion(),
-      exists: existsSync3(path)
+      exists: existsSync5(path)
     };
   }
   getStorageDir() {
@@ -8188,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)
       };
     }
   }
@@ -8204,11 +9565,11 @@ class OpenCodeAdapter {
   describeStorageSubtrees() {
     const storage = this.getStorageDir();
     return {
-      index: dirSize(join3(storage, "index")),
-      semantic: dirSize(join3(storage, "semantic")),
-      backups: dirSize(join3(storage, "backups")),
-      url_cache: dirSize(join3(storage, "url_cache")),
-      onnxruntime: dirSize(join3(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"))
     };
   }
 }
@@ -8216,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 execSync2, spawnSync } from "node:child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { execSync as execSync3, spawnSync as spawnSync2 } from "node:child_process";
+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 : homedir3();
-  return join4(home, ".pi", "agent");
+  const home = envHome && envHome.length > 0 ? envHome : homedir5();
+  return join6(home, ".pi", "agent");
 }
 function readPiExtensionIndex() {
-  const settingsPath = join4(getPiAgentDir(), "settings.json");
-  if (existsSync4(settingsPath)) {
+  const settingsPath = join6(getPiAgentDir(), "settings.json");
+  if (existsSync6(settingsPath)) {
     try {
       const raw = readFileSync3(settingsPath, "utf-8");
       const trimmed = raw.replace(/^\uFEFF/, "");
@@ -8246,13 +9607,13 @@ function readPiExtensionIndex() {
     } catch {}
   }
   const candidates = [
-    join4(getPiAgentDir(), "extensions.json"),
-    join4(getPiAgentDir(), "extensions.jsonc"),
-    join4(getPiAgentDir(), "config.json"),
-    join4(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 (!existsSync4(path))
+    if (!existsSync6(path))
       continue;
     try {
       const { value } = readJsoncFile(path);
@@ -8285,15 +9646,15 @@ function piEntryMatchesAft(entry) {
   } else if (entry.startsWith("/")) {
     resolved = entry;
   } else if (entry.length > 0) {
-    resolved = join4(getPiAgentDir(), entry);
+    resolved = join6(getPiAgentDir(), entry);
   }
   if (!resolved)
     return false;
   try {
-    if (!existsSync4(resolved))
+    if (!existsSync6(resolved))
       return false;
-    const pkgPath = join4(resolved, "package.json");
-    if (!existsSync4(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;
@@ -8313,7 +9674,7 @@ class PiAdapter {
   pluginEntryWithVersion = PLUGIN_ENTRY2;
   isInstalled() {
     try {
-      execSync2("pi --version", { stdio: "ignore" });
+      execSync3("pi --version", { stdio: "ignore", timeout: 5000 });
       return true;
     } catch {
       return false;
@@ -8321,9 +9682,10 @@ class PiAdapter {
   }
   getHostVersion() {
     try {
-      const result = spawnSync("pi", ["--version"], {
+      const result = spawnSync2("pi", ["--version"], {
         stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8"
+        encoding: "utf-8",
+        timeout: 5000
       });
       if (result.status !== 0)
         return null;
@@ -8342,7 +9704,7 @@ class PiAdapter {
     const aft = detectJsoncFile(configDir, "aft");
     return {
       configDir,
-      harnessConfig: index.path ?? join4(configDir, "extensions.json"),
+      harnessConfig: index.path ?? join6(configDir, "extensions.json"),
       harnessConfigFormat: index.path ? "json" : "none",
       aftConfig: aft.path,
       aftConfigFormat: aft.format
@@ -8369,29 +9731,29 @@ class PiAdapter {
       };
     }
     try {
-      execSync2(`pi install ${PLUGIN_ENTRY2}`, { stdio: "inherit" });
+      execSync3(`pi install ${PLUGIN_ENTRY2}`, { stdio: "inherit" });
       return {
         ok: true,
         action: "added",
         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 = [
-      join4(getPiAgentDir(), "node_modules", "@cortexkit", "aft-pi", "package.json"),
-      join4(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 (!existsSync4(candidate))
+      if (!existsSync6(candidate))
         continue;
       try {
         const pkg = JSON.parse(readFileSync3(candidate, "utf-8"));
@@ -8405,7 +9767,7 @@ class PiAdapter {
       } catch {}
     }
     return {
-      path: join4(getPiAgentDir(), "extensions"),
+      path: join6(getPiAgentDir(), "extensions"),
       exists: false
     };
   }
@@ -8427,11 +9789,11 @@ class PiAdapter {
   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(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"))
     };
   }
 }
@@ -8439,11 +9801,14 @@ 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}`;
 });
 
 // src/adapters/index.ts
+function getAllAdapters() {
+  return ALL;
+}
 function getAdapter(kind) {
   const found = ALL.find((a) => a.kind === kind);
   if (!found)
@@ -8614,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;
@@ -8630,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: "",
@@ -8834,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/;
@@ -9114,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"];
@@ -9736,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("◆", "*");
@@ -9850,7 +11215,7 @@ async function text(message, options = {}) {
   return result;
 }
 var init_prompts = __esm(() => {
-  init_dist4();
+  init_dist5();
 });
 
 // src/lib/harness-select.ts
@@ -9903,11 +11268,59 @@ async function resolveAdaptersForCommand(argv, options) {
   })), installed.map((a) => a.kind));
   return picks.map((kind) => getAdapter(kind));
 }
+function getAllRegistryAdapters() {
+  return getAllAdapters();
+}
 var init_harness_select = __esm(() => {
   init_adapters();
   init_prompts();
 });
 
+// src/commands/version.ts
+var exports_version = {};
+__export(exports_version, {
+  runVersion: () => runVersion
+});
+function runVersion() {
+  const cliVersion = getSelfVersion();
+  const binaryVersion = probeBinaryVersion();
+  const lines = [];
+  lines.push("");
+  lines.push("  AFT versions");
+  lines.push("");
+  lines.push(`  @cortexkit/aft (this CLI)   v${cliVersion}`);
+  lines.push(`  aft binary                  ${binaryVersion ?? "not installed"}`);
+  lines.push("");
+  const adapters = getAllRegistryAdapters();
+  const labelWidth = Math.max(...adapters.map((adapter) => adapter.displayName.length));
+  for (const adapter of adapters) {
+    const label = adapter.displayName.padEnd(labelWidth);
+    if (!adapter.isInstalled()) {
+      lines.push(`  ${label}   host not installed`);
+      continue;
+    }
+    const host = adapter.getHostVersion() ?? "unknown";
+    const registered = adapter.hasPluginEntry();
+    let pluginPart;
+    if (!registered) {
+      pluginPart = "plugin not registered";
+    } else {
+      const cached = adapter.getPluginCacheInfo().cached;
+      pluginPart = cached ? `plugin ${cached}` : "plugin registered (version unknown)";
+    }
+    lines.push(`  ${label}   host ${host} · ${pluginPart}`);
+  }
+  lines.push("");
+  console.log(lines.join(`
+`));
+  return 0;
+}
+var init_version = __esm(async () => {
+  init_harness_select();
+  init_self_version();
+  await init_binary_probe();
+});
+
 // src/commands/setup.ts
 var exports_setup = {};
 __export(exports_setup, {
@@ -9950,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);
   }
@@ -9986,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;
@@ -9998,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 = [];
@@ -10056,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)
@@ -10101,167 +11514,6 @@ ${stderrTrimmed}`);
 var MAX_NOISE_LINES_IN_ERROR = 5;
 var init_aft_bridge = () => {};
 
-// src/lib/binary-probe.ts
-import { execSync as execSync3, spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir4 } from "node:os";
-import { join as join5 } from "node:path";
-async function loadPluginVersion() {
-  try {
-    const bridgePackageName = "@cortexkit/aft-bridge";
-    const bridge = await import(bridgePackageName);
-    if (typeof bridge.PLUGIN_VERSION === "string" && bridge.PLUGIN_VERSION.length > 0) {
-      return bridge.PLUGIN_VERSION;
-    }
-  } catch {}
-  const require2 = createRequire2(import.meta.url);
-  for (const relPath of [
-    "../../../aft-bridge/package.json",
-    "../../package.json",
-    "../package.json"
-  ]) {
-    try {
-      const pkg = require2(relPath);
-      if (typeof pkg.version === "string" && pkg.version.length > 0)
-        return pkg.version;
-    } catch {}
-  }
-  return "unknown";
-}
-function parseVersionOutput(output) {
-  for (const line of output.split(/\r?\n/)) {
-    const match = line.trim().match(VERSION_LINE);
-    if (match?.[1])
-      return match[1];
-  }
-  return null;
-}
-function majorMinor(version) {
-  if (!version)
-    return null;
-  const match = version.trim().match(/^v?(\d+)\.(\d+)\.\d+(?:[-+][0-9A-Za-z.-]+)?$/);
-  if (!match)
-    return null;
-  return `${match[1]}.${match[2]}`;
-}
-function versionMatchesExpected(candidate, expectedVersion) {
-  const candidateMajorMinor = majorMinor(candidate);
-  const expectedMajorMinor = majorMinor(expectedVersion);
-  return candidateMajorMinor !== null && candidateMajorMinor === expectedMajorMinor;
-}
-function probeBinaryVersion(preferredVersion) {
-  return probeAftBinary(preferredVersion).version;
-}
-function probeAftBinary(preferredVersion) {
-  const expectedVersion = preferredVersion ?? PLUGIN_VERSION;
-  const expectedMajorMinor = majorMinor(expectedVersion);
-  const candidates = [];
-  for (const candidate of aftBinaryCandidates(preferredVersion)) {
-    try {
-      if (!existsSync5(candidate))
-        continue;
-      const result = spawnSync2(candidate, ["--version"], {
-        stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8",
-        timeout: 5000,
-        env: process.env
-      });
-      const output = `${result.stdout ?? ""}
-${result.stderr ?? ""}`.trim();
-      if (result.error || result.status !== 0) {
-        candidates.push({
-          path: candidate,
-          status: "error",
-          version: null,
-          ...output ? { output } : {},
-          error: result.error?.message ?? `exit status ${result.status ?? "unknown"}`
-        });
-        continue;
-      }
-      const version = parseVersionOutput(output);
-      if (!version) {
-        candidates.push({ path: candidate, status: "invalid", version: null, output });
-        continue;
-      }
-      if (!versionMatchesExpected(version, expectedVersion)) {
-        candidates.push({ path: candidate, status: "unmatched", version, output });
-        continue;
-      }
-      candidates.push({ path: candidate, status: "matched", version, output });
-      return { version, path: candidate, expectedVersion, expectedMajorMinor, candidates };
-    } catch (error) {
-      candidates.push({
-        path: candidate,
-        status: "error",
-        version: null,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  return { version: null, path: null, expectedVersion, expectedMajorMinor, candidates };
-}
-function pushCandidate(candidates, candidate) {
-  if (!candidate)
-    return;
-  if (!candidates.includes(candidate))
-    candidates.push(candidate);
-}
-function firstExisting(candidates) {
-  for (const candidate of candidates) {
-    try {
-      if (!existsSync5(candidate))
-        continue;
-      return candidate;
-    } catch {}
-  }
-  return null;
-}
-function platformKey(platform = process.platform, arch = process.arch) {
-  const table = {
-    darwin: { arm64: "darwin-arm64", x64: "darwin-x64" },
-    linux: { arm64: "linux-arm64", x64: "linux-x64" },
-    win32: { x64: "win32-x64" }
-  };
-  return table[platform]?.[arch] ?? null;
-}
-function aftBinaryCandidates(preferredVersion) {
-  const candidates = [];
-  if (preferredVersion) {
-    const tag = preferredVersion.startsWith("v") ? preferredVersion : `v${preferredVersion}`;
-    pushCandidate(candidates, join5(getAftBinaryCacheDir(), tag, getAftBinaryName()));
-  }
-  const key = platformKey();
-  if (key) {
-    try {
-      const require2 = createRequire2(import.meta.url);
-      pushCandidate(candidates, require2.resolve(`@cortexkit/aft-${key}/bin/${getAftBinaryName()}`));
-    } catch {}
-  }
-  try {
-    const lookup = process.platform === "win32" ? "where aft" : "which aft";
-    const resolved = execSync3(lookup, {
-      stdio: "pipe",
-      encoding: "utf-8",
-      env: process.env
-    }).trim();
-    if (resolved) {
-      pushCandidate(candidates, resolved.split(/\r?\n/)[0]);
-    }
-  } catch {}
-  pushCandidate(candidates, join5(homedir4(), ".cargo", "bin", getAftBinaryName()));
-  return candidates;
-}
-function findAftBinary(preferredVersion) {
-  return firstExisting(aftBinaryCandidates(preferredVersion));
-}
-var PLUGIN_VERSION, VERSION_LINE;
-var init_binary_probe = __esm(async () => {
-  init_paths();
-  PLUGIN_VERSION = await loadPluginVersion();
-  VERSION_LINE = /^(?:aft\s+)?v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)$/i;
-});
-
 // src/commands/lsp.ts
 var exports_lsp = {};
 __export(exports_lsp, {
@@ -10270,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);
@@ -10313,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;
@@ -10421,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 {};
 }
@@ -10488,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 {
@@ -10549,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();
@@ -10579,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]");
@@ -10610,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;
@@ -10622,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;
@@ -10798,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) {
@@ -10821,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,
@@ -10835,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;
     }
@@ -10851,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 = [];
@@ -10870,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;
@@ -10924,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";
@@ -10937,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") {
@@ -10992,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 })) {
@@ -11006,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;
@@ -11036,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;
 }
@@ -11062,7 +12314,7 @@ function parseOrtVersionFromDirectoryPath(value) {
   return null;
 }
 function detectOrtVersion(libDir) {
-  if (!existsSync10(libDir))
+  if (!existsSync11(libDir))
     return null;
   const libName = getOnnxLibraryName();
   try {
@@ -11077,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;
@@ -11109,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;
   }
@@ -11141,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)])) {
@@ -11188,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) {
@@ -11222,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);
@@ -11245,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
     },
@@ -11265,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
     }
   };
 }
@@ -11465,7 +12717,7 @@ function formatDiagnosticIssuesSection(report) {
   return lines;
 }
 function tailLogFile(path, lines) {
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return "";
   if (lines <= 0)
     return "";
@@ -11473,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;
@@ -11481,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) {
@@ -11496,7 +12748,7 @@ function tailLogFile(path, lines) {
   } finally {
     if (fd !== null) {
       try {
-        closeSync(fd);
+        closeSync2(fd);
       } catch {}
     }
   }
@@ -11552,6 +12804,12 @@ function createGitHubIssue(repo, title, body) {
 var init_github = () => {};
 
 // src/lib/issue-body.ts
+function filterLogToSession(logText, sessionId) {
+  const bareId = sessionId.replace(/^ses_/, "");
+  const keepTokens = [`[ses_${bareId}]`, `[${bareId}]`];
+  return logText.split(/\r?\n/).filter((line) => !SESSION_TAG_PATTERN.test(line) || keepTokens.some((token) => line.includes(token))).join(`
+`);
+}
 function isErrorLogLine(line) {
   return ERROR_LOG_PATTERNS.some((rx) => rx.test(line));
 }
@@ -11586,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]
@@ -11596,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(`
@@ -11629,8 +12887,9 @@ function truncateToByteBudget(input, maxBytes) {
   }
   return buf.subarray(0, end).toString("utf8");
 }
-var MAX_GITHUB_BODY_BYTES = 60000, ERROR_LOG_PATTERNS;
+var MAX_GITHUB_BODY_BYTES = 60000, SESSION_TAG_PATTERN, ERROR_LOG_PATTERNS;
 var init_issue_body = __esm(() => {
+  SESSION_TAG_PATTERN = /\[ses_[^\]\s]+\]|\[[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\]/;
   ERROR_LOG_PATTERNS = [
     /\bcrashed:/i,
     /\bfailed:/i,
@@ -11644,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) {
@@ -11653,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;
@@ -11662,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;
     }
@@ -11671,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
       });
     }
   }
@@ -11701,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;
     }
@@ -11726,6 +12985,189 @@ var init_onnx_fix = __esm(() => {
   init_prompts();
 });
 
+// src/lib/sessions.ts
+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 homedir8 } from "node:os";
+import { basename as basename2, join as join12 } from "node:path";
+function listRecentSessions(adapter) {
+  try {
+    if (adapter.kind === "opencode")
+      return listRecentOpenCodeSessions();
+    if (adapter.kind === "pi")
+      return listRecentPiSessions();
+    return [];
+  } catch {
+    return [];
+  }
+}
+function mapOpenCodeSessionRows(rows) {
+  return rows.map((row) => {
+    if (typeof row.id !== "string" || row.id.length === 0)
+      return null;
+    if (typeof row.title !== "string" || row.title.length === 0)
+      return null;
+    const lastActivity = typeof row.time_updated === "number" ? row.time_updated : Number(row.time_updated);
+    if (!Number.isFinite(lastActivity))
+      return null;
+    return {
+      id: row.id,
+      title: row.title,
+      lastActivity
+    };
+  }).filter((session) => session !== null).sort((a, b) => b.lastActivity - a.lastActivity).slice(0, MAX_RECENT_SESSIONS);
+}
+function listRecentOpenCodeSessions() {
+  const dbPath = join12(getXdgDataHome(), "opencode", "opencode.db");
+  if (!existsSync14(dbPath))
+    return [];
+  let db = null;
+  try {
+    const require2 = createRequire3(import.meta.url);
+    const sqlite = require2("node:sqlite");
+    db = new sqlite.DatabaseSync(dbPath, { readOnly: true });
+    const rows = db.prepare("SELECT id, title, time_updated FROM session ORDER BY time_updated DESC LIMIT 5").all();
+    return mapOpenCodeSessionRows(rows);
+  } catch {
+    return [];
+  } finally {
+    try {
+      db?.close();
+    } catch {}
+  }
+}
+function getXdgDataHome() {
+  const xdgDataHome = process.env.XDG_DATA_HOME;
+  return xdgDataHome && xdgDataHome.length > 0 ? xdgDataHome : join12(homedir8(), ".local", "share");
+}
+function listRecentPiSessions() {
+  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 : homedir8();
+}
+function listPiSessionsFromDir(sessionsDir) {
+  try {
+    if (!existsSync14(sessionsDir))
+      return [];
+    const files = collectJsonlFiles(sessionsDir).map((filePath) => {
+      try {
+        const stats = statSync8(filePath);
+        return { filePath, mtimeMs: stats.mtimeMs };
+      } catch {
+        return null;
+      }
+    }).filter((entry) => entry !== null).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_RECENT_SESSIONS * 4);
+    const sessions = [];
+    for (const file of files) {
+      const parsed = parsePiSessionJsonl(readFileSync4(file.filePath, "utf8"), basename2(file.filePath));
+      if (!parsed)
+        continue;
+      sessions.push({ ...parsed, lastActivity: file.mtimeMs });
+      if (sessions.length >= MAX_RECENT_SESSIONS)
+        break;
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+function collectJsonlFiles(root) {
+  const files = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (!dir)
+      continue;
+    let entries;
+    try {
+      entries = readdirSync6(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const path = join12(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(path);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(path);
+      }
+    }
+  }
+  return files;
+}
+function parsePiSessionJsonl(jsonl, fallbackFilename = "") {
+  let id = extractUuidFromFilename(fallbackFilename);
+  let title = null;
+  for (const line of jsonl.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+      continue;
+    let value;
+    try {
+      value = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!value || typeof value !== "object")
+      continue;
+    const record = value;
+    if (record.type === "session" && typeof record.id === "string" && record.id.length > 0) {
+      id = record.id;
+    }
+    if (title === null) {
+      const maybeTitle = extractPiUserMessageText(record);
+      if (maybeTitle)
+        title = truncateTitle(maybeTitle);
+    }
+    if (id && title)
+      break;
+  }
+  if (!id)
+    return null;
+  return { id, title: title ?? id };
+}
+function extractPiUserMessageText(record) {
+  if (record.type !== "message")
+    return null;
+  const message = record.message;
+  if (!message || typeof message !== "object")
+    return null;
+  const messageRecord = message;
+  if (messageRecord.role !== "user")
+    return null;
+  return extractTextFromContent(messageRecord.content);
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string")
+    return content.trim() || null;
+  if (!Array.isArray(content))
+    return null;
+  const parts = content.map((part) => {
+    if (typeof part === "string")
+      return part;
+    if (!part || typeof part !== "object")
+      return "";
+    const partRecord = part;
+    return partRecord.type === "text" && typeof partRecord.text === "string" ? partRecord.text : "";
+  }).filter((text2) => text2.trim().length > 0);
+  const joined = parts.join(" ").trim();
+  return joined.length > 0 ? joined : null;
+}
+function extractUuidFromFilename(filename) {
+  const match = filename.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i);
+  return match?.[1] ?? null;
+}
+function truncateTitle(title, maxLength = 60) {
+  const normalized = title.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength)
+    return normalized;
+  return `${normalized.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+var MAX_RECENT_SESSIONS = 5;
+var init_sessions = () => {};
+
 // src/commands/doctor.ts
 var exports_doctor = {};
 __export(exports_doctor, {
@@ -11743,18 +13185,18 @@ __export(exports_doctor, {
   DOCTOR_CLEAR_TARGET_OPTIONS: () => DOCTOR_CLEAR_TARGET_OPTIONS
 });
 import {
-  chmodSync,
-  existsSync as existsSync13,
-  mkdirSync as mkdirSync2,
+  chmodSync as chmodSync2,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync3,
   mkdtempSync,
-  readFileSync as readFileSync4,
-  realpathSync as realpathSync3,
+  readFileSync as readFileSync5,
+  realpathSync as realpathSync4,
   rmSync as rmSync4,
-  statSync as statSync8,
+  statSync as statSync9,
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join13 } from "node:path";
 async function runDoctor(options) {
   if (options.issue) {
     return runIssueFlow(options.argv);
@@ -11767,7 +13209,7 @@ async function runDoctor(options) {
     return runClearFlow(options.argv);
   }
   const adapters = await resolveAdaptersForCommand(options.argv, {
-    allowMulti: true,
+    allowMulti: false,
     verb: "diagnose"
   });
   const report = await collectDiagnostics(adapters);
@@ -11798,6 +13240,10 @@ async function runDoctor(options) {
     O2.info(`  aft config: ${h.aftConfig.exists ? h.configPaths.aftConfig : "(not set)"}`);
     if (h.aftConfig.parseError) {
       O2.error(`  aft config parse error: ${h.aftConfig.parseError}`);
+    } else if (h.aftConfig.exists) {
+      const { value } = readJsoncFile(h.configPaths.aftConfig);
+      const schemaSet = value?.$schema === AFT_SCHEMA_URL;
+      O2.info(`  aft config $schema: ${schemaSet ? "set" : "not set — run `aft doctor --fix` for editor autocomplete"}`);
     }
     O2.info(`  storage: ${formatDoctorStorageStatus(h)}`);
     if (h.onnxRuntime.required) {
@@ -11904,7 +13350,7 @@ function clearOldBinaries() {
     errors: [],
     keptVersion: keepTag
   };
-  if (!existsSync13(info.path)) {
+  if (!existsSync15(info.path)) {
     O2.info(`Binary cache: nothing to clear at ${info.path}`);
     return result;
   }
@@ -11914,10 +13360,10 @@ function clearOldBinaries() {
     return result;
   }
   for (const version of stale) {
-    const dir = join11(info.path, version);
+    const dir = join13(info.path, version);
     let bytes = 0;
     try {
-      bytes = statSync8(dir).isDirectory() ? dirSize(dir) : 0;
+      bytes = statSync9(dir).isDirectory() ? dirSize(dir) : 0;
     } catch {
       bytes = 0;
     }
@@ -11937,6 +13383,42 @@ function clearOldBinaries() {
   }
   return result;
 }
+function findSchemaFixTargets(adapters) {
+  const targets = [];
+  for (const adapter of adapters) {
+    if (!adapter.isInstalled())
+      continue;
+    let aftConfig;
+    let aftConfigFormat;
+    try {
+      ({ aftConfig, aftConfigFormat } = adapter.detectConfigPaths());
+    } catch {
+      continue;
+    }
+    const { value } = readJsoncFile(aftConfig);
+    if (value?.$schema === AFT_SCHEMA_URL)
+      continue;
+    targets.push({ adapter, aftConfig, aftConfigFormat });
+  }
+  return targets;
+}
+function applySchemaFixes(targets) {
+  let changed = 0;
+  let errors = 0;
+  for (const target of targets) {
+    try {
+      const result = ensureAftSchemaUrl(target.aftConfig, target.aftConfigFormat);
+      if (result.action === "added" || result.action === "updated") {
+        changed += 1;
+        O2.success(`${target.adapter.displayName}: ${result.message}`);
+      }
+    } catch (error2) {
+      errors += 1;
+      O2.warn(`${target.adapter.displayName}: could not set $schema on ${target.aftConfig}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    }
+  }
+  return { changed, errors };
+}
 function buildDoctorFixPlan(adapters, report) {
   const items = [];
   const adaptersByKind = new Map(adapters.map((adapter) => [adapter.kind, adapter]));
@@ -11984,6 +13466,12 @@ function buildDoctorFixPlan(adapters, report) {
       });
     }
   }
+  for (const target of findSchemaFixTargets(adapters)) {
+    items.push({
+      kind: "schema",
+      message: `Will add the AFT config $schema URL to ${target.aftConfig} (editor autocomplete + validation)`
+    });
+  }
   return items;
 }
 function shouldSkipDoctorFixConfirmation(argv) {
@@ -12022,7 +13510,7 @@ function logUnmatchedBinaryCandidates(expectedVersion) {
 }
 async function runFixFlow(argv) {
   const adapters = await resolveAdaptersForCommand(argv, {
-    allowMulti: true,
+    allowMulti: false,
     verb: "auto-fix issues for"
   });
   O2.info("Running diagnostics to identify auto-fixable issues…");
@@ -12044,6 +13532,7 @@ async function runFixFlow(argv) {
   }
   await fixPluginEntries(adapters);
   const storageSummary = ensureStorageDirsForRegisteredPlugins(adapters);
+  const schemaSummary = applySchemaFixes(findSchemaFixTargets(adapters));
   let binaryDownloaded = false;
   let binaryDownloadSkipped = false;
   let binaryDownloadError = null;
@@ -12055,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;
@@ -12072,7 +13561,7 @@ async function runFixFlow(argv) {
     }
   }
   const onnxResult = await runOnnxFix(adapters, report, { yes: true });
-  if (onnxResult === null && !binaryDownloaded && !binaryDownloadSkipped && !binaryDownloadError && storageSummary.created === 0 && storageSummary.errors === 0) {
+  if (onnxResult === null && !binaryDownloaded && !binaryDownloadSkipped && !binaryDownloadError && storageSummary.created === 0 && storageSummary.errors === 0 && schemaSummary.changed === 0 && schemaSummary.errors === 0) {
     O2.info("No auto-fixable issues detected.");
     wt("If you're still seeing 'Semantic Index: failed' in the TUI sidebar, run `aft doctor` (without --fix) for a full diagnostic dump.", "Tip");
     const afterReport2 = await collectDiagnostics(adapters);
@@ -12080,7 +13569,7 @@ async function runFixFlow(argv) {
     gt(stillHasProblems2 ? "Done — some issues remain." : "Done.");
     return stillHasProblems2 ? 1 : 0;
   }
-  const hadErrors = (onnxResult?.errors.length ?? 0) > 0 || binaryDownloadError !== null || storageSummary.errors > 0;
+  const hadErrors = (onnxResult?.errors.length ?? 0) > 0 || binaryDownloadError !== null || storageSummary.errors > 0 || schemaSummary.errors > 0;
   const afterReport = await collectDiagnostics(adapters);
   const stillHasProblems = hasDoctorProblems(afterReport);
   gt(hadErrors ? "Done — some fixes failed." : stillHasProblems ? "Done — some issues remain." : "Done.");
@@ -12135,9 +13624,9 @@ function ensureStorageDirsForRegisteredPlugins(adapters) {
       if (!adapter.isInstalled() || !adapter.hasPluginEntry())
         continue;
       const storageDir = adapter.getStorageDir();
-      if (existsSync13(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) {
@@ -12238,14 +13727,14 @@ function deriveIssueTitleFromBody(body) {
 function writeIssueReviewFile(body) {
   let reviewDir = null;
   try {
-    reviewDir = mkdtempSync(join11(tmpdir2(), "aft-issue-"));
+    reviewDir = mkdtempSync(join13(tmpdir2(), "aft-issue-"));
     if (process.platform !== "win32") {
-      chmodSync(reviewDir, 448);
+      chmodSync2(reviewDir, 448);
     }
-    const outPath = join11(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 {
@@ -12258,17 +13747,38 @@ 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;
     }
-    return readFileSync4(reviewFile.path, "utf8");
+    return readFileSync5(reviewFile.path, "utf8");
   } catch (err) {
     O2.error(`Failed to read reviewed issue report: ${err instanceof Error ? err.message : String(err)}`);
     return null;
   }
 }
+async function promptForIssueSession(adapter) {
+  const sessions = listRecentSessions(adapter);
+  if (sessions.length === 0)
+    return null;
+  const allLogsValue = "__all__";
+  const selected = await selectOne("Is this issue about a specific session?", [
+    { label: "General — not session-specific (include all logs)", value: allLogsValue },
+    ...sessions.map((session) => ({
+      label: truncateTitle(session.title),
+      value: session.id,
+      hint: shortSessionId(session.id)
+    }))
+  ]);
+  if (selected === allLogsValue)
+    return null;
+  return sessions.find((session) => session.id === selected) ?? null;
+}
+function shortSessionId(id) {
+  const bareId = id.replace(/^ses_/, "");
+  return bareId.length <= 12 ? bareId : bareId.slice(0, 12);
+}
 async function runIssueFlow(argv) {
   mt("AFT doctor --issue");
   if (!isInteractiveTerminal()) {
@@ -12277,28 +13787,33 @@ async function runIssueFlow(argv) {
     return 0;
   }
   const adapters = await resolveAdaptersForCommand(argv, {
-    allowMulti: true,
+    allowMulti: false,
     verb: "include in the issue"
   });
   const description = await text("Describe the problem you're running into:", {
     placeholder: "What happened? What did you expect? Steps to reproduce…",
     validate: (value) => value.trim().length === 0 ? "Please enter a short description." : undefined
   });
+  const selectedSession = await promptForIssueSession(adapters[0]);
+  const selectedBareSessionId = selectedSession?.id.replace(/^ses_/, "") ?? null;
   const report = await collectDiagnostics(adapters);
   const logSections = adapters.map((adapter) => {
     const path = adapter.getLogFile();
     const tail = tailLogFile(path, 200);
+    const scopedTail = selectedBareSessionId ? filterLogToSession(tail, selectedBareSessionId) : tail;
     return `#### ${adapter.displayName} log (${path})
 
 \`\`\`
-${tail || "<no log output>"}
+${scopedTail || "<no log output>"}
 \`\`\`
 `;
   }).join(`
 `);
   const errorScanWindow = adapters.map((adapter) => {
     const path = adapter.getLogFile();
-    return sanitizeContent(tailLogFile(path, 4000));
+    const tail = tailLogFile(path, 4000);
+    const scopedTail = selectedBareSessionId ? filterLogToSession(tail, selectedBareSessionId) : tail;
+    return sanitizeContent(scopedTail);
   }).join(`
 `);
   const recentErrorLines = extractRecentErrors(errorScanWindow, 20);
@@ -12314,6 +13829,7 @@ ${tail || "<no log output>"}
     `- AFT binary: ${report.binaryVersion ?? "unknown"}`,
     `- OS: ${report.platform} ${report.arch}`,
     `- Node: ${report.nodeVersion}`,
+    ...selectedSession ? [`- Session: ses_${selectedBareSessionId} (${truncateTitle(selectedSession.title)})`] : [],
     "",
     "## Diagnostics",
     renderDiagnosticsMarkdown(report),
@@ -12378,11 +13894,13 @@ var init_doctor = __esm(async () => {
   init_github();
   init_harness_select();
   init_issue_body();
+  init_jsonc();
   init_lsp_cache();
   init_onnx_fix();
   init_prompts();
   init_sanitize();
   init_self_version();
+  init_sessions();
   await __promiseAll([
     init_binary_probe(),
     init_diagnostics()
@@ -12413,6 +13931,7 @@ function printHelp() {
   console.log("  -------");
   console.log("");
   console.log("  Commands:");
+  console.log("    --version        Show CLI, binary, and per-harness plugin versions");
   console.log("    setup            Interactive setup wizard");
   console.log("    doctor           Check and fix configuration issues");
   console.log("    doctor lsp <file> Inspect LSP setup for one file");
@@ -12434,6 +13953,10 @@ function printHelp() {
   console.log("");
 }
 async function main() {
+  if (command === "--version" || command === "-v" || command === "-V" || command === "version") {
+    const { runVersion: runVersion2 } = await init_version().then(() => exports_version);
+    return runVersion2();
+  }
   if (command === "setup") {
     const { runSetup: runSetup2 } = await Promise.resolve().then(() => (init_setup(), exports_setup));
     return runSetup2(args);