@cortexkit/aft-opencode 0.39.4 → 0.40.1

package/dist/tui.js

@@ -4568,45 +4568,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;
@@ -7276,19 +7276,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];
@@ -7637,10 +7637,10 @@ var require_stringify = __commonJS((exports, module) => {
     replacer = null;
     indent = EMPTY;
   };
-  var join4 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
+  var join5 = (one, two, gap) => one ? two ? one + two.trim() + LF + gap : one.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(one, gap)), gap) : two ? two.trimRight() + repeat_line_breaks(Math.max(1, count_trailing_line_breaks(two, gap)), gap) : EMPTY;
   var join_content = (inside, value, gap) => {
     const comment = process_comments(value, PREFIX_BEFORE, gap + indent, true);
-    return join4(comment, inside, gap);
+    return join5(comment, inside, gap);
   };
   var stringify_string = (holder, key, value) => {
     const raw = get_raw_string_literal(holder, key);
@@ -7662,13 +7662,13 @@ var require_stringify = __commonJS((exports, module) => {
       if (i !== 0) {
         inside += COMMA;
       }
-      const before = join4(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
+      const before = join5(after_comma, process_comments(value, BEFORE(i), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += stringify(i, value, deeper_gap) || STR_NULL;
       inside += process_comments(value, AFTER_VALUE(i), deeper_gap);
       after_comma = process_comments(value, AFTER(i), deeper_gap);
     }
-    inside += join4(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join5(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return BRACKET_OPEN + join_content(inside, value, gap) + BRACKET_CLOSE;
   };
   var object_stringify = (value, gap) => {
@@ -7689,13 +7689,13 @@ var require_stringify = __commonJS((exports, module) => {
         inside += COMMA;
       }
       first = false;
-      const before = join4(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
+      const before = join5(after_comma, process_comments(value, BEFORE(key), deeper_gap), deeper_gap);
       inside += before || LF + deeper_gap;
       inside += quote(key) + process_comments(value, AFTER_PROP(key), deeper_gap) + COLON + process_comments(value, AFTER_COLON(key), deeper_gap) + SPACE + sv + process_comments(value, AFTER_VALUE(key), deeper_gap);
       after_comma = process_comments(value, AFTER(key), deeper_gap);
     };
     keys.forEach(iteratee);
-    inside += join4(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
+    inside += join5(after_comma, process_comments(value, PREFIX_AFTER, deeper_gap), deeper_gap);
     return CURLY_BRACKET_OPEN + join_content(inside, value, gap) + CURLY_BRACKET_CLOSE;
   };
   function stringify(key, holder, gap) {
@@ -7790,26 +7790,1244 @@ var require_src2 = __commonJS((exports, module) => {
 // src/tui/index.tsx
 import { createMemo as createMemo2, createSignal as createSignal2, onCleanup as onCleanup2 } from "solid-js";
 // package.json
-var version = "0.39.4";
+var version = "0.40.1";
 
 // src/shared/rpc-client.ts
 import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { createHash } from "node:crypto";
+import { join as join2 } from "node:path";
+
+// ../aft-bridge/dist/active-logger.js
+var ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
+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}`);
+  }
+}
+// ../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";
+
+// ../aft-bridge/dist/command-timeouts.js
+var PASSIVE_COMMANDS = new Set(["status"]);
+var PASSIVE_COMMAND_TIMEOUT_MS = 5000;
+function isPassiveCommand(command) {
+  return PASSIVE_COMMANDS.has(command);
+}
+
+// ../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
+var DEFAULT_BRIDGE_TIMEOUT_MS = 30000;
+var BRIDGE_HANG_TIMEOUT_THRESHOLD = 2;
+var MAX_STDOUT_BUFFER = 64 * 1024 * 1024;
+var STDOUT_BUFFER_COMPACT_THRESHOLD = 64 * 1024;
+var TERMINAL_BASH_STATUSES = new Set([
+  "completed",
+  "failed",
+  "killed",
+  "timed_out",
+  "cancelled",
+  "timeout"
+]);
+function isTerminalBashStatus(status) {
+  return typeof status === "string" && TERMINAL_BASH_STATUSES.has(status);
+}
+function bashTaskIdFrom(response) {
+  const snakeCase = response.task_id;
+  if (typeof snakeCase === "string" && snakeCase.length > 0)
+    return snakeCase;
+  const camelCase = response.taskId;
+  if (typeof camelCase === "string" && camelCase.length > 0)
+    return camelCase;
+  return;
+}
+function tagStderrLine(line) {
+  return /^\[aft(-\w+)?\] /.test(line) ? line : `[aft] ${line}`;
+}
+var BENIGN_CPUINFO_PROC_CPUINFO_PARSE_FAILURE = "failed to parse processor information from /proc/cpuinfo";
+function shouldSurfaceStderrLine(line) {
+  const normalized = line.trim();
+  return !(normalized === `Error in cpuinfo: ${BENIGN_CPUINFO_PROC_CPUINFO_PARSE_FAILURE}` || normalized === BENIGN_CPUINFO_PROC_CPUINFO_PARSE_FAILURE);
+}
+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 coerceConfigureDroppedKeys(value) {
+  if (!Array.isArray(value))
+    return [];
+  const dropped = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item))
+      continue;
+    const record = item;
+    if (typeof record.key === "string" && typeof record.tier === "string" && typeof record.reason === "string") {
+      dropped.push({ key: record.key, tier: record.tier, reason: record.reason });
+    }
+  }
+  return dropped;
+}
+
+class BridgeReplacedDuringVersionCheck extends Error {
+  newBinaryPath;
+  constructor(newBinaryPath) {
+    super(`Bridge binary replaced during version check: ${newBinaryPath}`);
+    this.newBinaryPath = newBinaryPath;
+    this.name = "BridgeReplacedDuringVersionCheck";
+  }
+}
+
+class BridgeTransportTimeoutError extends Error {
+  command;
+  timeoutMs;
+  code = "transport_timeout";
+  constructor(command, timeoutMs, message) {
+    super(message);
+    this.command = command;
+    this.timeoutMs = timeoutMs;
+    this.name = "BridgeTransportTimeoutError";
+  }
+}
+class BinaryBridge {
+  static RESTART_RESET_MS = 5 * 60 * 1000;
+  static STDERR_TAIL_MAX = 20;
+  binaryPath;
+  cwd;
+  process = null;
+  pending = new Map;
+  outstandingBackgroundTaskIds = new Set;
+  nextId = 1;
+  stdoutBuffer = "";
+  stdoutReadOffset = 0;
+  stderrBuffer = "";
+  stderrTail = [];
+  _restartCount = 0;
+  _shuttingDown = false;
+  timeoutMs;
+  hangThreshold;
+  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.hangThreshold = options?.hangThreshold ?? BRIDGE_HANG_TIMEOUT_THRESHOLD;
+    this.maxRestarts = options?.maxRestarts ?? 3;
+    this.configOverrides = configOverrides ?? {};
+    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;
+  }
+  hasOutstandingBackgroundTasks() {
+    return this.outstandingBackgroundTaskIds.size > 0;
+  }
+  getCwd() {
+    return this.cwd;
+  }
+  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 passive = isPassiveCommand(command);
+      const resolvedTimeoutMs = options?.transportTimeoutMs ?? options?.timeoutMs ?? this.timeoutMs;
+      const effectiveTimeoutMs = passive ? Math.min(resolvedTimeoutMs, PASSIVE_COMMAND_TIMEOUT_MS) : resolvedTimeoutMs;
+      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 = passive || 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 BridgeTransportTimeoutError(command, effectiveTimeoutMs, `${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 < this.hangThreshold;
+          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, command });
+        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)
+      return;
+    const warnings = Array.isArray(configResult.warnings) ? configResult.warnings : [];
+    const configDroppedKeys = coerceConfigureDroppedKeys(configResult.config_dropped_keys);
+    if (warnings.length === 0 && configDroppedKeys.length === 0)
+      return;
+    const sessionId = typeof params.session_id === "string" ? params.session_id : undefined;
+    const context = {
+      projectRoot: this.cwd,
+      sessionId,
+      client: options?.configureWarningClient ?? (sessionId ? this.configureWarningClients.get(sessionId) : undefined),
+      warnings
+    };
+    if (configDroppedKeys.length > 0) {
+      context.configDroppedKeys = configDroppedKeys;
+    }
+    try {
+      await this.onConfigureWarnings(context);
+    } 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;
+    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);
+      this.flushStdoutBuffer();
+    });
+    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.flushStdoutBuffer();
+      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.stdoutReadOffset = 0;
+    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 || !shouldSurfaceStderrLine(line))
+        continue;
+      const tagged = tagStderrLine(line);
+      this.logVia(tagged);
+      this.pushStderrLine(tagged);
+    }
+  }
+  flushStderrBuffer() {
+    const line = this.stderrBuffer.replace(/\r$/, "");
+    this.stderrBuffer = "";
+    if (!line || !shouldSurfaceStderrLine(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) {
+    if (this.stdoutReadOffset > STDOUT_BUFFER_COMPACT_THRESHOLD) {
+      this.compactStdoutBuffer();
+    }
+    this.stdoutBuffer += data;
+    if (this.stdoutBuffer.length - this.stdoutReadOffset > 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(`
+`, this.stdoutReadOffset)) !== -1) {
+      const line = this.stdoutBuffer.slice(this.stdoutReadOffset, newlineIdx).trim();
+      this.stdoutReadOffset = newlineIdx + 1;
+      if (line) {
+        this.processStdoutLine(line);
+      }
+      if (this.stdoutReadOffset > STDOUT_BUFFER_COMPACT_THRESHOLD && this.stdoutReadOffset > this.stdoutBuffer.length / 2) {
+        this.compactStdoutBuffer();
+      }
+    }
+    if (this.stdoutReadOffset === this.stdoutBuffer.length) {
+      this.stdoutBuffer = "";
+      this.stdoutReadOffset = 0;
+    }
+  }
+  compactStdoutBuffer() {
+    if (this.stdoutReadOffset === 0)
+      return;
+    this.stdoutBuffer = this.stdoutBuffer.slice(this.stdoutReadOffset);
+    this.stdoutReadOffset = 0;
+  }
+  flushStdoutBuffer() {
+    const line = this.stdoutBuffer.slice(this.stdoutReadOffset).trim();
+    this.stdoutBuffer = "";
+    this.stdoutReadOffset = 0;
+    if (!line)
+      return;
+    this.processStdoutLine(line);
+  }
+  processStdoutLine(line) {
+    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 });
+        return;
+      }
+      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
+          });
+        }
+        return;
+      }
+      if (response.type === "bash_completed") {
+        const taskId = bashTaskIdFrom(response);
+        if (taskId)
+          this.outstandingBackgroundTaskIds.delete(taskId);
+        this.onBashCompletion?.(response, this);
+        return;
+      }
+      if (response.type === "bash_long_running") {
+        this.onBashLongRunning?.(response, this);
+        return;
+      }
+      if (response.type === "bash_pattern_match") {
+        this.onBashPatternMatch?.(response, this);
+        return;
+      }
+      if (response.type === "configure_warnings") {
+        this.handleConfigureWarningsFrame(response).catch((err) => {
+          this.warnVia(`configure warning delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        return;
+      }
+      if (response.type === "status_changed") {
+        this.handleStatusChangedFrame(response);
+        return;
+      }
+      const id = response.id;
+      if (id && this.pending.has(id)) {
+        const entry = this.pending.get(id);
+        if (!entry)
+          return;
+        this.pending.delete(id);
+        clearTimeout(entry.timer);
+        this.consecutiveRequestTimeouts = 0;
+        this.scheduleRestartCountReset();
+        this.accountForBashTaskResponse(entry.command, response);
+        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}`);
+    }
+  }
+  accountForBashTaskResponse(command, response) {
+    const taskId = bashTaskIdFrom(response);
+    if (!taskId)
+      return;
+    if (isTerminalBashStatus(response.status)) {
+      this.outstandingBackgroundTaskIds.delete(taskId);
+      return;
+    }
+    if (command === "bash" && response.success !== false) {
+      this.outstandingBackgroundTaskIds.add(taskId);
+    }
+  }
+  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`));
+    this.outstandingBackgroundTaskIds.clear();
+    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;
+    this.outstandingBackgroundTaskIds.clear();
+    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/downloader.js
+var MAX_DOWNLOAD_BYTES = 200 * 1024 * 1024;
+var DOWNLOAD_LOCK_STALE_MS = 10 * 60000;
+// ../aft-bridge/dist/migration.js
+var DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+// ../aft-bridge/dist/onnx-runtime.js
+var ORT_VERSION = "1.24.4";
+var MAX_DOWNLOAD_BYTES2 = 256 * 1024 * 1024;
+var MAX_EXTRACT_BYTES = 1 * 1024 * 1024 * 1024;
+var STALE_LOCK_MS = 5 * 60 * 1000;
+var 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/project-identity.js
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+function canonicalizeProjectRoot(dir) {
+  const trimmed = dir.replace(/[/\\]+$/, "");
+  let canonical;
+  try {
+    canonical = realpathSync(trimmed);
+  } catch {
+    canonical = resolve(trimmed);
+  }
+  return normalizeWindowsRoot(canonical);
+}
+function normalizeWindowsRoot(p) {
+  if (process.platform !== "win32")
+    return p;
+  let s = p;
+  if (s.startsWith("\\\\?\\UNC\\")) {
+    s = `\\\\${s.slice("\\\\?\\UNC\\".length)}`;
+  } else if (s.startsWith("\\\\?\\")) {
+    s = s.slice("\\\\?\\".length);
+  }
+  if (s.length >= 2 && s[1] === ":") {
+    const drive = s.charCodeAt(0);
+    if (drive >= 97 && drive <= 122) {
+      s = s[0].toUpperCase() + s.slice(1);
+    }
+  }
+  return s;
+}
+function projectRootKeyHash(dir) {
+  return createHash("sha256").update(canonicalizeProjectRoot(dir)).digest("hex").slice(0, 16);
+}
+
+// ../aft-bridge/dist/pool.js
+var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+var DEFAULT_MAX_POOL_SIZE = 8;
+var CLEANUP_INTERVAL_MS = 60 * 1000;
+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,
+      hangThreshold: options.hangThreshold,
+      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() || entry.bridge.hasOutstandingBackgroundTasks())
+        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() || bridge.hasOutstandingBackgroundTasks())
+        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() || entry.bridge.hasOutstandingBackgroundTasks())
+        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) {
+  return canonicalizeProjectRoot(projectRoot);
+}
+// src/shared/rpc-utils.ts
 function projectHash(directory) {
-  const normalized = directory.replace(/\/+$/, "");
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+  return projectRootKeyHash(directory);
 }
 function rpcPortFilePath(storageDir, directory) {
   const hash = projectHash(directory);
-  return join(storageDir, "rpc", hash, "port");
+  return join2(storageDir, "rpc", hash, "port");
 }
 function rpcPortFileDir(storageDir, directory) {
   const hash = projectHash(directory);
-  return join(storageDir, "rpc", hash, "ports");
+  return join2(storageDir, "rpc", hash, "ports");
 }
 function isPidAlive(pid) {
   if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
@@ -7863,7 +9081,7 @@ function throwIfAborted(signal) {
 }
 function delay(ms, signal) {
   throwIfAborted(signal);
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let timer;
     const onAbort = () => {
       clearTimeout(timer);
@@ -7871,7 +9089,7 @@ function delay(ms, signal) {
     };
     timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve();
+      resolve2();
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -7984,7 +9202,7 @@ class AftRpcClient {
         for (const entry of readdirSync(this.portsDir)) {
           if (!entry.endsWith(".json"))
             continue;
-          const filePath = join2(this.portsDir, entry);
+          const filePath = join3(this.portsDir, entry);
           const info = this.parsePortFile(filePath);
           if (!info)
             continue;
@@ -8233,39 +9451,39 @@ function coerceAftStatus(response) {
 import { createEffect, createMemo, createSignal, on, onCleanup } from "solid-js";
 
 // src/shared/storage-paths.ts
-import { homedir } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join as join4 } from "node:path";
 function homeDir() {
   if (process.platform === "win32")
-    return process.env.USERPROFILE || process.env.HOME || homedir();
-  return process.env.HOME || homedir();
+    return process.env.USERPROFILE || process.env.HOME || homedir2();
+  return process.env.HOME || homedir2();
 }
 function dataHome() {
   if (process.env.XDG_DATA_HOME)
     return process.env.XDG_DATA_HOME;
   if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join3(homeDir(), "AppData", "Local");
+    return process.env.LOCALAPPDATA || process.env.APPDATA || join4(homeDir(), "AppData", "Local");
   }
-  return join3(homeDir(), ".local", "share");
+  return join4(homeDir(), ".local", "share");
 }
-function resolveCortexKitStorageRoot() {
-  return join3(dataHome(), "cortexkit", "aft");
+function resolveCortexKitStorageRoot2() {
+  return join4(dataHome(), "cortexkit", "aft");
 }
 
 // src/tui/preferences.ts
 var import_comment_json = __toESM(require_src2(), 1);
 import { watch } from "node:fs";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { basename, dirname, join as join4 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { basename, dirname, join as join5 } from "node:path";
 var TUI_PREFS_FILE_ENV = "OPENCODE_TUI_PREFERENCES_FILE";
 var FILE_NAME = "tui-preferences.jsonc";
 function getTuiPreferencesFile() {
   const override = process.env[TUI_PREFS_FILE_ENV];
   if (override)
     return override;
-  const configDir = process.env.OPENCODE_CONFIG_DIR || join4(process.env.XDG_CONFIG_HOME || join4(homedir2(), ".config"), "opencode");
-  return join4(configDir, FILE_NAME);
+  const configDir = process.env.OPENCODE_CONFIG_DIR || join5(process.env.XDG_CONFIG_HOME || join5(homedir3(), ".config"), "opencode");
+  return join5(configDir, FILE_NAME);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -8606,7 +9824,7 @@ function collapsedHealthLights(statusBar) {
   return { diagnostics, code, todos };
 }
 function resolveTuiStorageDir() {
-  return resolveCortexKitStorageRoot();
+  return resolveCortexKitStorageRoot2();
 }
 var sidebarClients = new Map;
 function getClient(directory) {
@@ -8628,16 +9846,16 @@ function shouldSuppressUninitializedDowngrade(incomingCacheRole, haveInitialized
   return incomingCacheRole === "not_initialized" && haveInitializedForContext;
 }
 function isSnapshotForContext(snapshot, directory, servedDirectory) {
-  const stripSlash = (p) => p.replace(/\/+$/, "");
+  const canon = (p) => canonicalizeProjectRoot(p);
   const roots = [snapshot.project_root, snapshot.canonical_root].filter((r) => typeof r === "string" && r.length > 0);
   if (roots.length === 0)
     return true;
-  const dir = stripSlash(directory);
-  if (roots.some((r) => stripSlash(r) === dir))
+  const dir = canon(directory);
+  if (roots.some((r) => canon(r) === dir))
     return true;
   if (typeof servedDirectory === "string" && servedDirectory.length > 0) {
-    const served = stripSlash(servedDirectory);
-    return roots.some((r) => stripSlash(r) === served);
+    const served = canon(servedDirectory);
+    return roots.some((r) => canon(r) === served);
   }
   return false;
 }
@@ -9123,7 +10341,6 @@ async function createAftSidebarSlot(api, pluginVersion) {
 
 // src/tui/index.tsx
 import { jsxDEV as jsxDEV2 } from "@opentui/solid/jsx-dev-runtime";
-var STATUS_COMMAND = "aft-status";
 var rpcClients = new Map;
 function getRpcClient(directory) {
   let client = rpcClients.get(directory);
@@ -9142,6 +10359,29 @@ function getSessionId(api) {
   } catch {}
   return null;
 }
+var lastReceivedNotificationIdBySession = new Map;
+async function consumeTuiMessages(client, sessionId) {
+  try {
+    const result = await client.call("consume-notifications", {
+      lastReceivedId: lastReceivedNotificationIdBySession.get(sessionId) ?? 0,
+      sessionId
+    });
+    return (result.messages ?? []).map((message) => ({
+      id: message.id,
+      type: message.type,
+      payload: message.payload,
+      sessionId: message.sessionId
+    }));
+  } catch {
+    return [];
+  }
+}
+function markTuiMessagesReceived(sessionId, messages) {
+  const previous = lastReceivedNotificationIdBySession.get(sessionId) ?? 0;
+  const next = messages.reduce((max, message) => Math.max(max, message.id), previous);
+  if (next > previous)
+    lastReceivedNotificationIdBySession.set(sessionId, next);
+}
 var POLL_INTERVAL_MS2 = 1500;
 function formatCountShort(value) {
   if (value == null || !Number.isFinite(value))
@@ -9214,7 +10454,7 @@ var StatusDialog = (props) => {
   const theme = createMemo2(() => props.api.theme.current);
   const t = () => theme();
   const [status, setStatus] = createSignal2(props.initial);
-  const [error, setError] = createSignal2(props.initialError);
+  const [error2, setError] = createSignal2(props.initialError);
   let pollGeneration = 0;
   let pollController = null;
   const pollStatus = async () => {
@@ -9287,12 +10527,12 @@ var StatusDialog = (props) => {
           }, undefined, true, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      error() ? /* @__PURE__ */ jsxDEV2("box", {
+      error2() ? /* @__PURE__ */ jsxDEV2("box", {
         width: "100%",
         marginBottom: 1,
         children: /* @__PURE__ */ jsxDEV2("text", {
           fg: t().warning,
-          children: error()
+          children: error2()
         }, undefined, false, undefined, this)
       }, undefined, false, undefined, this) : null,
       status()?.cache_role === "not_initialized" ? /* @__PURE__ */ jsxDEV2("box", {
@@ -9650,24 +10890,15 @@ async function showStatusDialog(api) {
   } catch {
     initialError = "AFT is starting up. Status will refresh automatically...";
   }
-  const dismissStatusDialog = () => {
-    api.ui.dialog.setSize("medium");
-    api.ui.dialog.clear();
-  };
+  api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(StatusDialog, {
+    api,
+    client,
+    directory,
+    sessionID,
+    initial,
+    initialError
+  }, undefined, false, undefined, this));
   api.ui.dialog.setSize("large");
-  api.ui.dialog.replace(() => /* @__PURE__ */ jsxDEV2(api.ui.Dialog, {
-    size: "large",
-    onClose: dismissStatusDialog,
-    children: /* @__PURE__ */ jsxDEV2(StatusDialog, {
-      api,
-      client,
-      directory,
-      sessionID,
-      initial,
-      initialError,
-      onClose: dismissStatusDialog
-    }, undefined, false, undefined, this)
-  }, undefined, false, undefined, this), dismissStatusDialog);
 }
 function registerStatusCommand(api) {
   const apiAny = api;
@@ -9679,7 +10910,6 @@ function registerStatusCommand(api) {
           name: "aft.status",
           title: "AFT: Status",
           category: "AFT",
-          slashName: STATUS_COMMAND,
           run() {
             showStatusDialog(api);
           }
@@ -9695,7 +10925,6 @@ function registerStatusCommand(api) {
         title: "AFT: Status",
         value: "aft.status",
         category: "AFT",
-        slash: { name: STATUS_COMMAND },
         onSelect() {
           showStatusDialog(api);
         }
@@ -9753,6 +10982,47 @@ var tui = async (api) => {
     api.slots.register(await createAftSidebarSlot(api, version));
   } catch {}
   registerStatusCommand(api);
+  let pollInFlight = false;
+  const messagePoller = setInterval(() => {
+    if (pollInFlight)
+      return;
+    const requestedSessionId = getSessionId(api);
+    if (!requestedSessionId)
+      return;
+    const directory = api.state.path.directory ?? "";
+    if (!directory)
+      return;
+    pollInFlight = true;
+    const client = getRpcClient(directory);
+    consumeTuiMessages(client, requestedSessionId).then(async (messages) => {
+      if (getSessionId(api) !== requestedSessionId)
+        return;
+      const orderedMessages = [...messages].sort((a, b) => a.id - b.id);
+      for (const message of orderedMessages) {
+        if (getSessionId(api) !== requestedSessionId)
+          return;
+        if (message.sessionId && message.sessionId !== requestedSessionId)
+          continue;
+        if (message.type !== "action")
+          continue;
+        if (message.payload?.action !== "show-status-dialog")
+          continue;
+        await showStatusDialog(api);
+      }
+      if (getSessionId(api) !== requestedSessionId)
+        return;
+      markTuiMessagesReceived(requestedSessionId, orderedMessages);
+    }).catch(() => {}).finally(() => {
+      pollInFlight = false;
+    });
+  }, 500);
+  api.lifecycle?.onDispose?.(() => {
+    clearInterval(messagePoller);
+    lastReceivedNotificationIdBySession.clear();
+    for (const client of rpcClients.values())
+      client.reset();
+    rpcClients.clear();
+  });
   showStartupNotifications(api);
 };
 var id = "aft-opencode";