@cortexkit/aft-opencode 0.58.0 → 0.58.1

package/dist/index.js

@@ -7878,6 +7878,9 @@ function isTerminalStatus(status) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function monotonicNowMs() {
+  return performance.now();
+}
 // ../aft-bridge/dist/bash-hints.js
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -7888,6 +7891,10 @@ function resolveWatchTimeoutMs(requestedMs, role, capMs) {
   const fallback = role === "worker" ? capMs : DEFAULT_PRIMARY_WATCH_TIMEOUT_MS;
   return Math.min(requestedMs ?? fallback, capMs);
 }
+function formatWatchWaited(elapsedMs, limitMs, capMs) {
+  const limit = limitMs >= capMs ? `limit ${limitMs}ms, the bash.watch_sync_max_ms cap` : `limit ${limitMs}ms`;
+  return `Waited ${Math.round(elapsedMs)}ms (${limit})`;
+}
 function watchTimeoutSteer(role, capMs, timeoutParam = "timeoutMs") {
   if (role === "worker") {
     return `The command is still running; this is not a failure. Watch again (${timeoutParam} up to ${capMs}) and don't report a result until it finishes.`;
@@ -8274,7 +8281,7 @@ import { existsSync } from "node:fs";
 import { join as join3 } from "node:path";
 
 // ../aft-bridge/dist/child-process.js
-import { execFileSync as nodeExecFileSync, execSync as nodeExecSync, spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
+import { execFile as nodeExecFile, execFileSync as nodeExecFileSync, execSync as nodeExecSync, spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "node:child_process";
 var HIDDEN = { windowsHide: true };
 function withWindowsHidden(args, takesArgv) {
   const out = [...args];
@@ -8296,6 +8303,7 @@ function hidden(resolve, takesArgv) {
 }
 var spawn = hidden(() => nodeSpawn, true);
 var spawnSync = hidden(() => nodeSpawnSync, true);
+var execFile = hidden(() => nodeExecFile, true);
 var execFileSync = hidden(() => nodeExecFileSync, true);
 var execSync = hidden(() => nodeExecSync, false);
 
@@ -9622,17 +9630,30 @@ class BinaryBridge {
     }
   }
   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);
+    const partialLimit = 64 * 1024;
+    let offset = 0;
+    while (offset < data.length) {
+      const newline = data.indexOf(`
+`, offset);
+      const end = newline < 0 ? data.length : newline;
+      while (offset < end) {
+        const count = Math.min(partialLimit - this.stderrBuffer.length, end - offset);
+        this.stderrBuffer += data.slice(offset, offset + count);
+        offset += count;
+        if (this.stderrBuffer.length === partialLimit) {
+          const last = this.stderrBuffer.charCodeAt(this.stderrBuffer.length - 1);
+          const carry = last >= 55296 && last <= 56319 ? this.stderrBuffer.slice(-1) : "";
+          const fragment = carry ? this.stderrBuffer.slice(0, -1) : this.stderrBuffer;
+          const tagged = tagStderrLine(`${fragment} [stderr record truncated into bounded fragments; ${Buffer.byteLength(fragment)} bytes shown, continuation follows]`);
+          this.stderrBuffer = carry;
+          this.logVia(tagged);
+          this.pushStderrLine(tagged);
+        }
+      }
+      if (newline < 0)
+        break;
+      this.flushStderrBuffer();
+      offset = newline + 1;
     }
   }
   flushStderrBuffer() {
@@ -10121,9 +10142,366 @@ function formatDroppedKeyWarnings(dropped) {
   }
   return dropped.map((item) => `Ignoring ${item.key} from ${item.tier} config (${item.reason})`);
 }
+// ../aft-bridge/dist/config-watch.js
+import { readFileSync as readFileSync3, statSync as statSync3, watch } from "node:fs";
+import { basename, dirname } from "node:path";
+var CONFIG_WATCH_DEBOUNCE_MS = 150;
+var CONFIG_LIVE_KEEP_NOTE = "AFT keeps using the last valid configuration until the file is fixed.";
+function pathKey(name) {
+  const segments = name.split(".");
+  return {
+    name,
+    read(config) {
+      let value = config;
+      for (const segment of segments) {
+        if (value === null || typeof value !== "object")
+          return;
+        value = value[segment];
+      }
+      return value;
+    },
+    write(config, value) {
+      const set = (target, index) => {
+        const copy = target !== null && typeof target === "object" && !Array.isArray(target) ? { ...target } : {};
+        const segment = segments[index];
+        if (index === segments.length - 1) {
+          if (value === undefined)
+            delete copy[segment];
+          else
+            copy[segment] = value;
+        } else {
+          copy[segment] = set(copy[segment], index + 1);
+        }
+        return copy;
+      };
+      return set(config, 0);
+    }
+  };
+}
+function bashKey(name, resolveBash) {
+  return {
+    name: `bash.${name}`,
+    read: (config) => resolveBash(config)[name],
+    write(config, value) {
+      const resolved = { ...resolveBash(config), [name]: value };
+      for (const key of Object.keys(resolved)) {
+        if (resolved[key] === undefined)
+          delete resolved[key];
+      }
+      return { ...config, bash: resolved };
+    }
+  };
+}
+function aftLiveConfigKeys(resolveBash) {
+  return [
+    pathKey("configure_warnings_delivery"),
+    pathKey("restrict_to_project_root"),
+    pathKey("inspect.diagnostics_timeout_ms"),
+    pathKey("inspect.tier2_idle_minutes"),
+    bashKey("foreground_wait_window_ms", resolveBash),
+    bashKey("host_fallback", resolveBash),
+    bashKey("subagent_background", resolveBash),
+    bashKey("watch_sync_max_ms", resolveBash)
+  ];
+}
+function sameValue(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function flattenLeaves(value, prefix, out) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0 && prefix)
+      out.set(prefix, "{}");
+    for (const [key, child] of entries) {
+      flattenLeaves(child, prefix ? `${prefix}.${key}` : key, out);
+    }
+    return;
+  }
+  if (prefix)
+    out.set(prefix, JSON.stringify(value));
+}
+function applyLiveConfigKeys(current, next, keys, baseline = current) {
+  let config = current;
+  const applied = [];
+  for (const key of keys) {
+    const value = key.read(next);
+    if (sameValue(key.read(current), value))
+      continue;
+    config = key.write(config, value);
+    applied.push(key.name);
+  }
+  const before = new Map;
+  const after = new Map;
+  flattenLeaves(baseline, "", before);
+  flattenLeaves(next, "", after);
+  const liveNames = keys.map((key) => key.name);
+  const isLive = (leaf) => liveNames.some((name) => leaf === name || leaf.startsWith(`${name}.`));
+  const deferred = new Set;
+  for (const leaf of new Set([...before.keys(), ...after.keys()])) {
+    if (before.get(leaf) === after.get(leaf) || isLive(leaf))
+      continue;
+    deferred.add(leaf);
+  }
+  return { config, applied, deferred: [...deferred].sort() };
+}
+function readTextOrNull(path) {
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+var CONFIG_WATCH_REVALIDATE_MS = 2000;
+var CONFIG_WATCH_REJECTED_RETRIES = 3;
+var CONFIG_WATCH_MAX_DELAY_MS = 1000;
+function identityOf(dir) {
+  try {
+    const stat = statSync3(dir, { bigint: true });
+    const base = `${stat.dev}:${stat.ino}`;
+    return process.platform === "win32" ? base : `${base}:${stat.birthtimeNs}`;
+  } catch {
+    return null;
+  }
+}
+function watchDirFor(file) {
+  let dir = dirname(file);
+  while (dir !== dirname(dir) && identityOf(dir) === null)
+    dir = dirname(dir);
+  return dir;
+}
+function watchAftConfigFiles(options) {
+  const debounceMs = options.debounceMs ?? CONFIG_WATCH_DEBOUNCE_MS;
+  const lastSeen = new Map;
+  for (const path of options.paths) {
+    if (options.initialTexts)
+      lastSeen.set(path, options.initialTexts[path] ?? null);
+    else
+      lastSeen.set(path, options.checkAtStart ? undefined : readTextOrNull(path));
+  }
+  let timer = null;
+  let firstPendingAt = null;
+  let stopped = false;
+  const watchers = new Map;
+  const watchImpl = options.watchImpl ?? watch;
+  let rejectedRetries = 0;
+  const check = () => {
+    timer = null;
+    firstPendingAt = null;
+    if (stopped)
+      return;
+    revalidate();
+    const seen = new Map;
+    for (const path of options.paths) {
+      const text = readTextOrNull(path);
+      if (text !== lastSeen.get(path))
+        seen.set(path, text);
+    }
+    if (seen.size === 0)
+      return;
+    const outcome = options.onChange();
+    if (outcome === false) {
+      if (rejectedRetries < CONFIG_WATCH_REJECTED_RETRIES) {
+        rejectedRetries += 1;
+        retryTimer = setTimeout(check, CONFIG_WATCH_MAX_DELAY_MS);
+        retryTimer.unref?.();
+      }
+      return;
+    }
+    rejectedRetries = 0;
+    if (outcome instanceof Map) {
+      for (const path of options.paths)
+        lastSeen.set(path, outcome.get(path) ?? null);
+    } else {
+      for (const [path, text] of seen)
+        lastSeen.set(path, text);
+    }
+  };
+  let retryTimer = null;
+  const schedule = () => {
+    if (stopped)
+      return;
+    const now = Date.now();
+    firstPendingAt ??= now;
+    if (timer)
+      clearTimeout(timer);
+    const delay = Math.max(0, Math.min(debounceMs, firstPendingAt + CONFIG_WATCH_MAX_DELAY_MS - now));
+    timer = setTimeout(check, delay);
+    timer.unref?.();
+  };
+  function revalidate() {
+    const wanted = new Set(options.paths.map(watchDirFor));
+    let moved = false;
+    for (const [dir, entry] of watchers) {
+      if (!wanted.has(dir) || entry.stale || identityOf(dir) !== entry.identity) {
+        entry.watcher.close();
+        watchers.delete(dir);
+        moved = true;
+      }
+    }
+    for (const dir of wanted) {
+      if (watchers.has(dir))
+        continue;
+      try {
+        const identity = identityOf(dir);
+        options.beforeWatchForTest?.(dir);
+        const name = basename(dir);
+        const watcher = watchImpl(dir, { persistent: false }, (event, filename) => {
+          if (event === "rename" && filename === name) {
+            const current = watchers.get(dir);
+            if (current && current.watcher === watcher)
+              current.stale = true;
+          }
+          schedule();
+        });
+        if (identityOf(dir) !== identity) {
+          watcher.close();
+          moved = true;
+          continue;
+        }
+        const entry = { watcher, identity, stale: false };
+        entry.watcher.on("error", () => {
+          entry.watcher.close();
+          if (watchers.get(dir) === entry)
+            watchers.delete(dir);
+          schedule();
+        });
+        watchers.set(dir, entry);
+        moved = true;
+      } catch {}
+    }
+    return moved;
+  }
+  revalidate();
+  if (options.checkAtStart)
+    check();
+  const revalidateTimer = setInterval(() => {
+    if (!stopped && revalidate())
+      schedule();
+  }, CONFIG_WATCH_REVALIDATE_MS);
+  revalidateTimer.unref?.();
+  return () => {
+    stopped = true;
+    if (timer)
+      clearTimeout(timer);
+    if (retryTimer)
+      clearTimeout(retryTimer);
+    clearInterval(revalidateTimer);
+    for (const entry of watchers.values())
+      entry.watcher.close();
+    watchers.clear();
+  };
+}
+function aftLiveSecurityKeys(keys) {
+  const byName = new Map(keys.map((key) => [key.name, key]));
+  const pick = (name) => {
+    const key = byName.get(name);
+    if (!key)
+      throw new Error(`unknown live config key ${name}`);
+    return key;
+  };
+  return [
+    {
+      key: pick("restrict_to_project_root"),
+      loosens: (current, next) => current === true && next !== true
+    },
+    {
+      key: pick("bash.host_fallback"),
+      loosens: (current, next) => current !== true && next === true
+    }
+  ];
+}
+function liveConfigReloadLogLine(applied, deferred) {
+  let line = "config reload";
+  if (applied.length > 0)
+    line += ` applied=[${applied.join(",")}]`;
+  if (deferred.length > 0) {
+    line += ` deferred=[${deferred.join(",")}] (deferred keys apply on next connect/restart)`;
+  }
+  return line;
+}
+function startLiveConfigReload(options) {
+  const baseline = options.getConfig();
+  let lastError = null;
+  let acceptedSources = new Set(options.initialSources);
+  let acceptedProjectText = options.initialProjectText ?? null;
+  let acceptedTexts;
+  const reload = () => {
+    let loaded = options.load();
+    if (loaded.ok) {
+      const read = new Set(loaded.sources);
+      const deleted = [...acceptedSources].find((path) => !read.has(path));
+      if (deleted !== undefined) {
+        loaded = { ok: false, message: `AFT config at ${deleted} was deleted` };
+      } else {
+        acceptedSources = read;
+      }
+    }
+    if (!loaded.ok) {
+      const message = `${loaded.message.trim().replace(/[.!?]?$/, ".")} ${CONFIG_LIVE_KEEP_NOTE}`;
+      if (message !== lastError) {
+        lastError = message;
+        options.reportError(message);
+      }
+      return null;
+    }
+    lastError = null;
+    acceptedTexts = loaded.texts;
+    const current = options.getConfig();
+    let next = loaded.config;
+    const held = [];
+    const projectText = loaded.projectText ?? null;
+    if (loaded.projectText !== undefined && projectText !== acceptedProjectText) {
+      for (const security of options.securityKeys ?? []) {
+        const now = security.key.read(current);
+        if (security.loosens(now, security.key.read(next))) {
+          next = security.key.write(next, now);
+          held.push(security.key.name);
+        }
+      }
+      if (held.length === 0)
+        acceptedProjectText = projectText;
+    }
+    const result = applyLiveConfigKeys(current, next, options.keys, baseline);
+    if (result.applied.length > 0)
+      options.setConfig(result.config);
+    if (result.applied.length > 0 || result.deferred.length > 0 || held.length > 0) {
+      let line = liveConfigReloadLogLine(result.applied, result.deferred);
+      if (held.length > 0) {
+        line += ` held=[${held.join(",")}] (not loosened while the project file differs from the one the published values came from; the next restart applies them)`;
+      }
+      options.log(line);
+    }
+    return { ...result, held };
+  };
+  const safeReload = () => {
+    try {
+      acceptedTexts = undefined;
+      if (reload() === null)
+        return false;
+      const texts = acceptedTexts;
+      if (!texts)
+        return true;
+      return new Map(options.paths.map((path) => [path, texts[path] ?? null]));
+    } catch (err) {
+      options.reportError(`AFT config reload failed: ${err instanceof Error ? err.message : String(err)}`);
+      return false;
+    }
+  };
+  if (options.watch === false) {
+    return { reload, stop: () => {} };
+  }
+  const stop = watchAftConfigFiles({
+    paths: options.paths,
+    debounceMs: options.debounceMs,
+    onChange: safeReload,
+    initialTexts: options.initialTexts,
+    checkAtStart: true
+  });
+  return { reload, stop };
+}
 // ../aft-bridge/dist/downloader.js
 import { createHash as createHash2, randomUUID } from "node:crypto";
-import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync as existsSync3, mkdirSync, openSync, readdirSync, readFileSync as readFileSync3, renameSync as renameSync2, rmSync, statSync as statSync3, unlinkSync as unlinkSync2, writeSync } from "node:fs";
+import { chmodSync, closeSync, copyFileSync, createWriteStream, existsSync as existsSync3, mkdirSync, openSync, readdirSync, readFileSync as readFileSync4, renameSync as renameSync2, rmSync, statSync as statSync4, unlinkSync as unlinkSync2, writeSync } from "node:fs";
 import { hostname } from "node:os";
 import { join as join7 } from "node:path";
 import { Readable } from "node:stream";
@@ -10475,7 +10853,7 @@ function isReclaimableDownloadLock(owner, ageMs, staleMs) {
 }
 function reclaimDownloadLock(lockPath, expectedOwner) {
   try {
-    if (readFileSync3(lockPath, "utf-8") !== expectedOwner)
+    if (readFileSync4(lockPath, "utf-8") !== expectedOwner)
       return false;
     rmSync(lockPath, { force: true });
     return true;
@@ -10493,7 +10871,7 @@ function sweepStaleDownloadTemps(versionedCacheDir, binaryName) {
         continue;
       }
       const tempPath = join7(versionedCacheDir, entry.name);
-      const ageMs = Date.now() - statSync3(tempPath).mtimeMs;
+      const ageMs = Date.now() - statSync4(tempPath).mtimeMs;
       if (Math.abs(ageMs) > DOWNLOAD_LOCK_STALE_MS)
         unlinkSync2(tempPath);
     }
@@ -10515,7 +10893,7 @@ async function acquireDownloadLock(lockPath, timing = {}) {
       }
       return () => {
         try {
-          if (readFileSync3(lockPath, "utf-8") === owner) {
+          if (readFileSync4(lockPath, "utf-8") === owner) {
             rmSync(lockPath, { force: true });
           }
         } catch {}
@@ -10527,8 +10905,8 @@ async function acquireDownloadLock(lockPath, timing = {}) {
       let existingOwner;
       let ageMs;
       try {
-        existingOwner = readFileSync3(lockPath, "utf-8");
-        ageMs = Date.now() - statSync3(lockPath).mtimeMs;
+        existingOwner = readFileSync4(lockPath, "utf-8");
+        ageMs = Date.now() - statSync4(lockPath).mtimeMs;
       } catch (readErr) {
         if (readErr.code === "ENOENT")
           continue;
@@ -10578,7 +10956,7 @@ async function fetchLatestTag() {
 }
 // ../aft-bridge/dist/durable-log.js
 import { appendFile, chmod, mkdir, rename, rm, stat } from "node:fs/promises";
-import { dirname } from "node:path";
+import { dirname as dirname2 } from "node:path";
 var DEFAULT_LOG_BYTES = 32 * 1024 * 1024;
 var DEFAULT_LOG_GENERATIONS = 1;
 var LOG_DIR_MODE = 448;
@@ -10591,6 +10969,10 @@ class RotatingLogSink {
   queue = Promise.resolve();
   disabled = false;
   failureReported = false;
+  queuedBytes = 0;
+  queuedRecords = 0;
+  droppedBytes = 0;
+  overflowQueued = false;
   constructor(path, options = {}) {
     this.path = path;
     this.maxBytes = options.maxBytes ?? DEFAULT_LOG_BYTES;
@@ -10599,7 +10981,34 @@ class RotatingLogSink {
   append(data) {
     if (this.disabled || data.length === 0)
       return;
-    this.queue = this.queue.then(() => this.write(data)).catch((error) => {
+    const bytes = Buffer.byteLength(data);
+    const overflow = this.queuedBytes + bytes > 1024 * 1024 || this.queuedRecords >= 4096;
+    if (overflow) {
+      this.droppedBytes += bytes;
+      if (this.overflowQueued)
+        return;
+      this.overflowQueued = true;
+      data = "";
+    } else {
+      this.queuedBytes += bytes;
+      this.queuedRecords += 1;
+    }
+    this.queue = this.queue.then(async () => {
+      if (overflow) {
+        const dropped = this.droppedBytes;
+        this.droppedBytes = 0;
+        this.overflowQueued = false;
+        await this.write(`[aft-plugin] durable log queue overflow: dropped ${dropped} bytes (1MiB/4096-record pending limit); reduce diagnostic volume.
+`);
+      } else {
+        try {
+          await this.write(data);
+        } finally {
+          this.queuedBytes -= bytes;
+          this.queuedRecords -= 1;
+        }
+      }
+    }).catch((error) => {
       this.disabled = true;
       if (!this.failureReported) {
         this.failureReported = true;
@@ -10614,8 +11023,8 @@ class RotatingLogSink {
     await this.queue;
   }
   async write(data) {
-    const dir = dirname(this.path);
-    await mkdir(dirname(dir), { recursive: true });
+    const dir = dirname2(this.path);
+    await mkdir(dirname2(dir), { recursive: true });
     try {
       await mkdir(dir, { mode: LOG_DIR_MODE });
     } catch (error) {
@@ -12403,7 +12812,7 @@ function reverseRequestMethod(body) {
   }
 }
 // ../aft-bridge/dist/subc-transport.js
-import { existsSync as existsSync4, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync4, statSync as statSync5 } from "node:fs";
 
 // ../aft-bridge/dist/lifecycle-registry.js
 import { lstat } from "node:fs/promises";
@@ -12930,6 +13339,7 @@ var RECONNECT_RETRY_FLOOR_MS = 100;
 var RECONNECT_RETRY_CAP_MS = 2000;
 var SUBC_DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 var ROUTE_OPEN_RELOAD_WAIT_CEILING_MS = 45000;
+var CALL_DEADLINE_EXPIRED = Symbol("call deadline expired");
 function reloadWaitExhaustedSuffix(callDeadlineMs) {
   if (callDeadlineMs > ROUTE_OPEN_RELOAD_WAIT_CEILING_MS) {
     const ceilingSeconds = ROUTE_OPEN_RELOAD_WAIT_CEILING_MS / 1000;
@@ -13282,7 +13692,16 @@ function absentRootError(root) {
   return new SubcError(`invalid route project root: project root does not exist: ${root}`, "config_divergence");
 }
 function reloadWindowExhaustedError(error, callDeadlineMs) {
-  const suffix = reloadWaitExhaustedSuffix(callDeadlineMs);
+  return withDeadlineSuffix(error, reloadWaitExhaustedSuffix(callDeadlineMs));
+}
+function callDeadlinePassedError(lastError, callDeadlineMs) {
+  const seconds = Math.round(callDeadlineMs / 100) / 10;
+  const suffix = ` The AFT daemon module did not return within this call's ${seconds}s deadline.`;
+  if (lastError !== undefined)
+    return withDeadlineSuffix(lastError, suffix);
+  return new SubcError(`route to module '${AFT_MODULE_ID}' was not ready before the call ran out of time.${suffix}`, REQUEST_DEADLINE_CODE);
+}
+function withDeadlineSuffix(error, suffix) {
   if (error instanceof Error) {
     try {
       error.message += suffix;
@@ -13521,7 +13940,7 @@ class SubcTransportPool {
   rootCanAttach(root) {
     let directoryExists = false;
     try {
-      directoryExists = statSync4(root).isDirectory();
+      directoryExists = statSync5(root).isDirectory();
     } catch {}
     if (directoryExists) {
       this.dormantRoots.delete(root);
@@ -13861,6 +14280,7 @@ class SubcTransportPool {
     return this.rootReapedError(record);
   }
   async routeRequest(identity, body, timeoutMs, onProgress, expectedGeneration, abortSignal) {
+    const callStartedAt = performance.now();
     const root = asCanonicalRootPath(identity.project_root);
     let generation = expectedGeneration;
     if (this.lifecycleEnabled()) {
@@ -13913,19 +14333,41 @@ class SubcTransportPool {
       };
       const callDeadlineMs = timeoutMs ?? SUBC_DEFAULT_REQUEST_TIMEOUT_MS;
       const reloadWaitBudgetMs = Math.min(callDeadlineMs, ROUTE_OPEN_RELOAD_WAIT_CEILING_MS);
-      let reloadWaitedMs = 0;
+      let scheduledDelayMs = 0;
+      let lastRefusal;
+      const spentMs = () => Math.max(performance.now() - callStartedAt, scheduledDelayMs);
+      const remainingMs = () => callDeadlineMs - spentMs();
+      const openRouteWithinDeadline = async () => {
+        const remaining = remainingMs();
+        if (remaining <= 0)
+          throw callDeadlinePassedError(lastRefusal, callDeadlineMs);
+        let timer;
+        const expired = new Promise((resolve) => {
+          timer = setTimeout(() => resolve(CALL_DEADLINE_EXPIRED), remaining);
+        });
+        try {
+          const opened = await Promise.race([openRoute(), expired]);
+          if (opened === CALL_DEADLINE_EXPIRED) {
+            throw callDeadlinePassedError(lastRefusal, callDeadlineMs);
+          }
+          return opened;
+        } finally {
+          clearTimeout(timer);
+        }
+      };
       const openRouteAfterReloadWindow = async () => {
         while (true) {
           try {
-            return await openRoute();
+            return await openRouteWithinDeadline();
           } catch (error) {
             if (!isRouteOpenReloadWindowError(error))
               throw error;
-            if (reloadWaitedMs + this.nextRouteReopenDelayMs() >= reloadWaitBudgetMs) {
+            lastRefusal = error;
+            if (spentMs() + this.nextRouteReopenDelayMs() >= reloadWaitBudgetMs) {
               throw reloadWindowExhaustedError(error, callDeadlineMs);
             }
             const { delayMs, wait } = this.waitForRouteReopenBackoff();
-            reloadWaitedMs += delayMs;
+            scheduledDelayMs = spentMs() + delayMs;
             await wait;
           }
         }
@@ -13961,7 +14403,7 @@ class SubcTransportPool {
           route: routeLabel(entry.handle)
         });
       };
-      const requestOnRoute = async (route, entry) => {
+      const requestOnRoute = async (route, entry, requestTimeoutMs) => {
         this.assertRecordLive(record);
         if (abortSignal?.aborted) {
           clearRouteEntry(entry);
@@ -13977,8 +14419,10 @@ class SubcTransportPool {
         };
         abortSignal?.addEventListener("abort", onAbort, { once: true });
         try {
-          const requestTimeoutMs = reloadWaitedMs > 0 ? callDeadlineMs - reloadWaitedMs : timeoutMs;
-          const request = client.request(route, body, { timeoutMs: requestTimeoutMs, onProgress });
+          const request = client.request(route, body, {
+            timeoutMs: Math.ceil(requestTimeoutMs),
+            onProgress
+          });
           const reply = abortSignal ? await Promise.race([request, aborted]) : await request;
           if (!this.isCurrentSession(key, record)) {
             if (this.isReapInduced(record))
@@ -13999,8 +14443,11 @@ class SubcTransportPool {
       let reopened = false;
       let retriedAbsentRoute = false;
       while (true) {
+        const requestTimeoutMs = remainingMs();
+        if (requestTimeoutMs <= 0)
+          throw callDeadlinePassedError(lastRefusal, callDeadlineMs);
         try {
-          const reply = await requestOnRoute(routeAndEntry.route, routeAndEntry.entry);
+          const reply = await requestOnRoute(routeAndEntry.route, routeAndEntry.entry, requestTimeoutMs);
           if (reopened)
             this.resetRouteReopenBackoff();
           return reply;
@@ -14010,11 +14457,12 @@ class SubcTransportPool {
           const ownsRoute = this.isCurrentSession(key, record) && this.client === client;
           if (ownsRoute && isRouteRequestReloadRefusal(error)) {
             clearRouteEntry(routeAndEntry.entry);
-            if (reloadWaitedMs + this.nextRouteReopenDelayMs() >= reloadWaitBudgetMs) {
+            lastRefusal = error;
+            if (spentMs() + this.nextRouteReopenDelayMs() >= reloadWaitBudgetMs) {
               throw reloadWindowExhaustedError(error, callDeadlineMs);
             }
             const { delayMs, wait } = this.waitForRouteReopenBackoff();
-            reloadWaitedMs += delayMs;
+            scheduledDelayMs = spentMs() + delayMs;
             await wait;
             routeAndEntry = await openRouteAfterReloadWindow();
             reopened = true;
@@ -14023,7 +14471,12 @@ class SubcTransportPool {
           if (ownsRoute && !retriedAbsentRoute && isRouteProvenAbsentError(error)) {
             retriedAbsentRoute = true;
             clearRouteEntry(routeAndEntry.entry);
-            await this.waitForRouteReopenBackoff().wait;
+            if (spentMs() + this.nextRouteReopenDelayMs() >= callDeadlineMs) {
+              throw callDeadlinePassedError(error, callDeadlineMs);
+            }
+            const { delayMs, wait } = this.waitForRouteReopenBackoff();
+            scheduledDelayMs = spentMs() + delayMs;
+            await wait;
             routeAndEntry = await openRouteAfterReloadWindow();
             reopened = true;
             continue;
@@ -15846,14 +16299,14 @@ function shouldInterruptWaitsForMessage(detachOnUserMessage, operatorText) {
   return detachOnUserMessage || containsStandaloneDetachKeyword(operatorText);
 }
 // ../aft-bridge/dist/migration.js
-import { closeSync as closeSync3, existsSync as existsSync8, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync6, renameSync as renameSync4, rmSync as rmSync2, statSync as statSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { closeSync as closeSync3, existsSync as existsSync8, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync2, statSync as statSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir as homedir8, tmpdir as tmpdir2 } from "node:os";
-import { basename, dirname as dirname4, join as join10, resolve as resolve6 } from "node:path";
+import { basename as basename2, dirname as dirname5, join as join10, resolve as resolve6 } from "node:path";
 
 // ../aft-bridge/dist/paths.js
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync4, renameSync as renameSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync as renameSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname2, isAbsolute as isAbsolute3, join as join8, resolve as resolve5 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join8, resolve as resolve5 } from "node:path";
 function homeDir3() {
   if (process.platform === "win32")
     return process.env.USERPROFILE || process.env.HOME || homedir6();
@@ -15913,7 +16366,7 @@ function repairRootScopedStorageFile(storageRoot, harness, fileName) {
   if (existsSync6(harnessPath) || !existsSync6(rootPath))
     return harnessPath;
   try {
-    mkdirSync2(dirname2(harnessPath), { recursive: true });
+    mkdirSync2(dirname3(harnessPath), { recursive: true });
     renameSync3(rootPath, harnessPath);
   } catch {}
   return harnessPath;
@@ -15925,7 +16378,7 @@ function shouldShowAnnouncement(storageRoot, harness, currentVersion) {
   let lastVersion = "";
   try {
     if (existsSync6(versionFile)) {
-      lastVersion = readFileSync4(versionFile, "utf-8").trim();
+      lastVersion = readFileSync5(versionFile, "utf-8").trim();
     }
   } catch {
     return false;
@@ -15934,7 +16387,7 @@ function shouldShowAnnouncement(storageRoot, harness, currentVersion) {
     return false;
   if (!lastVersion) {
     try {
-      mkdirSync2(dirname2(versionFile), { recursive: true });
+      mkdirSync2(dirname3(versionFile), { recursive: true });
       writeFileSync2(versionFile, currentVersion);
     } catch {}
     return false;
@@ -15946,7 +16399,7 @@ function markAnnouncementSeen(storageRoot, harness, currentVersion) {
     return;
   const versionFile = repairRootScopedStorageFile(storageRoot, harness, "last_announced_version");
   try {
-    mkdirSync2(dirname2(versionFile), { recursive: true });
+    mkdirSync2(dirname3(versionFile), { recursive: true });
     writeFileSync2(versionFile, currentVersion);
   } catch {}
 }
@@ -15995,10 +16448,10 @@ function decodeFileUrl(target) {
 }
 
 // ../aft-bridge/dist/resolver.js
-import { closeSync as closeSync2, existsSync as existsSync7, promises as fsPromises, openSync as openSync2, readFileSync as readFileSync5, readSync } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync7, promises as fsPromises, openSync as openSync2, readFileSync as readFileSync6, readSync } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir as homedir7 } from "node:os";
-import { delimiter, dirname as dirname3, isAbsolute as isAbsolute4, join as join9 } from "node:path";
+import { delimiter, dirname as dirname4, isAbsolute as isAbsolute4, join as join9 } from "node:path";
 var ensureBinaryForResolver = ensureBinary;
 var npmPlatformPackageReader = null;
 var cacheCopiesInFlight = new Map;
@@ -16151,8 +16604,8 @@ function npmPlatformPackage(ext) {
   try {
     const req = createRequire(import.meta.url);
     const manifestPath = req.resolve(`@cortexkit/aft-${platformKey()}/package.json`);
-    const manifest = JSON.parse(readFileSync5(manifestPath, "utf8"));
-    const binaryPath = join9(dirname3(manifestPath), "bin", `aft${ext}`);
+    const manifest = JSON.parse(readFileSync6(manifestPath, "utf8"));
+    const binaryPath = join9(dirname4(manifestPath), "bin", `aft${ext}`);
     if (typeof manifest.version !== "string" || !existsSync7(binaryPath))
       return null;
     return { binaryPath, version: normalizeBareVersion(manifest.version) };
@@ -16406,7 +16859,7 @@ function acquireConfigMigrationLock(lockDir) {
       if (code !== "EEXIST")
         throw err;
       try {
-        const ageMs = Date.now() - statSync5(lockDir).mtimeMs;
+        const ageMs = Date.now() - statSync6(lockDir).mtimeMs;
         if (ageMs > 60000) {
           rmSync2(lockDir, { recursive: true, force: true });
           continue;
@@ -16420,12 +16873,12 @@ function acquireConfigMigrationLock(lockDir) {
   }
 }
 function atomicCopyConfigFile(sourcePath, targetPath) {
-  mkdirSync3(dirname4(targetPath), { recursive: true });
-  const tmpPath = join10(dirname4(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  mkdirSync3(dirname5(targetPath), { recursive: true });
+  const tmpPath = join10(dirname5(targetPath), `.${basename2(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd = null;
   try {
     fd = openSync3(tmpPath, "wx", 384);
-    writeFileSync3(fd, readFileSync6(sourcePath));
+    writeFileSync3(fd, readFileSync7(sourcePath));
     closeSync3(fd);
     fd = null;
     renameSync4(tmpPath, targetPath);
@@ -16442,8 +16895,8 @@ function atomicCopyConfigFile(sourcePath, targetPath) {
   }
 }
 function atomicWriteConfigFile(targetPath, content) {
-  mkdirSync3(dirname4(targetPath), { recursive: true });
-  const tmpPath = join10(dirname4(targetPath), `.${basename(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  mkdirSync3(dirname5(targetPath), { recursive: true });
+  const tmpPath = join10(dirname5(targetPath), `.${basename2(targetPath)}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   let fd = null;
   try {
     fd = openSync3(tmpPath, "wx", 384);
@@ -16504,11 +16957,11 @@ function markLegacySourcesMovedAside(sources, targetPath, logger) {
     const desiredMarkerPath = `${source.path}${MOVED_MARKER_SUFFIX}`;
     const markerPath = nonClobberingSidecarPath(desiredMarkerPath);
     try {
-      const original = readFileSync6(source.path, "utf-8");
+      const original = readFileSync7(source.path, "utf-8");
       if (markerPath !== desiredMarkerPath) {
         logger?.warn?.(`Preserving existing legacy AFT marker ${desiredMarkerPath}; writing new marker to ${markerPath}`);
       }
-      atomicWriteConfigFile(markerPath, movedMarkerContent(targetPath, basename(source.path), original));
+      atomicWriteConfigFile(markerPath, movedMarkerContent(targetPath, basename2(source.path), original));
       unlinkSync3(source.path);
       info?.(`Moved legacy AFT config ${source.path} aside to ${markerPath}; AFT now reads ${targetPath}`);
     } catch (err) {
@@ -16568,15 +17021,15 @@ function migrateAftConfigFile(opts) {
   if (existingSources.length === 0) {
     return { migrated: false, conflict: false, targetPath: opts.targetPath, warnings };
   }
-  mkdirSync3(dirname4(opts.targetPath), { recursive: true });
+  mkdirSync3(dirname5(opts.targetPath), { recursive: true });
   const release = acquireConfigMigrationLock(`${opts.targetPath}.lock`);
   try {
     const sources = existingSources.map((source) => ({
       ...source,
-      content: readFileSync6(source.path, "utf-8")
+      content: readFileSync7(source.path, "utf-8")
     }));
     if (existsSync8(opts.targetPath)) {
-      const targetContent = readFileSync6(opts.targetPath, "utf-8");
+      const targetContent = readFileSync7(opts.targetPath, "utf-8");
       for (const source of sources) {
         if (fileSemanticsMatch(source.content, targetContent))
           continue;
@@ -16627,11 +17080,11 @@ function spawnErrorLabel(error) {
 function migrationLogPath(newRoot, harness, logger) {
   const desired = join10(newRoot, "logs", "migration", `${harness}-${Date.now()}.jsonl`);
   try {
-    mkdirSync3(dirname4(desired), { recursive: true });
+    mkdirSync3(dirname5(desired), { recursive: true });
     return desired;
   } catch (err) {
     const fallback = join10(tmpdir2(), `aft-migration-${harness}-${Date.now()}.jsonl`);
-    logger?.warn?.(`Failed to create AFT migration log directory ${dirname4(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
+    logger?.warn?.(`Failed to create AFT migration log directory ${dirname5(desired)}: ${err instanceof Error ? err.message : String(err)}. ` + `Using fallback log path ${fallback}.`);
     return fallback;
   }
 }
@@ -16692,9 +17145,9 @@ async function ensureStorageMigrated(opts) {
   throw new Error(`AFT storage migration failed (${detail}). ` + `Harness: ${opts.harness}. Legacy: ${legacyRoot}. Target: ${newRoot}. ` + `See log: ${logPath}. ` + `Plugin load aborted to prevent legacy/new state divergence.` + (stderrTail ? ` Stderr tail: ${stderrTail}` : "") + (stdoutTail ? ` Stdout tail: ${stdoutTail}` : ""));
 }
 // ../aft-bridge/dist/migration-notices.js
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, renameSync as renameSync5, rmdirSync, statSync as statSync6, writeFileSync as writeFileSync4 } from "node:fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync as renameSync5, rmdirSync, statSync as statSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname5, join as join11, resolve as resolve7 } from "node:path";
+import { dirname as dirname6, join as join11, resolve as resolve7 } from "node:path";
 function migrationNoticeStorePath(env = process.env) {
   const stateHome = env.XDG_STATE_HOME && env.XDG_STATE_HOME.length > 0 ? env.XDG_STATE_HOME : join11(homedir9(), ".local", "state");
   return join11(stateHome, "cortexkit", "aft", "migration-notices.json");
@@ -16704,7 +17157,7 @@ function noticeKey(configPath, digest) {
 }
 function readRecords(storePath) {
   try {
-    const parsed = JSON.parse(readFileSync7(storePath, "utf8"));
+    const parsed = JSON.parse(readFileSync8(storePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -16713,7 +17166,7 @@ function readRecords(storePath) {
 var LOCK_STALE_MS = 1e4;
 function withStoreLock(storePath, action) {
   const lockPath = `${storePath}.lock`;
-  mkdirSync4(dirname5(storePath), { recursive: true });
+  mkdirSync4(dirname6(storePath), { recursive: true });
   const deadline = Date.now() + 2000;
   for (;; ) {
     try {
@@ -16723,7 +17176,7 @@ function withStoreLock(storePath, action) {
       if (error.code !== "EEXIST")
         throw error;
       try {
-        if (Date.now() - statSync6(lockPath).mtimeMs > LOCK_STALE_MS)
+        if (Date.now() - statSync7(lockPath).mtimeMs > LOCK_STALE_MS)
           rmdirSync(lockPath);
       } catch {}
       if (Date.now() > deadline)
@@ -16764,9 +17217,9 @@ function deliverMigrationNoticeOnce(options) {
   }
 }
 // ../aft-bridge/dist/npm-resolver.js
-import { readdirSync as readdirSync2, statSync as statSync7 } from "node:fs";
+import { readdirSync as readdirSync2, statSync as statSync8 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { dirname as dirname6, isAbsolute as isAbsolute5, join as join12 } from "node:path";
+import { dirname as dirname7, isAbsolute as isAbsolute5, join as join12 } from "node:path";
 function defaultDeps() {
   return {
     platform: process.platform,
@@ -16780,7 +17233,7 @@ function npmBinaryName(platform) {
 }
 function isFile(p) {
   try {
-    return statSync7(p).isFile();
+    return statSync8(p).isFile();
   } catch {
     return false;
   }
@@ -16801,7 +17254,7 @@ function npmFromPath(deps) {
   return null;
 }
 function npmAdjacentToNode(deps) {
-  const dir = dirname6(deps.execPath);
+  const dir = dirname7(deps.execPath);
   return isFile(join12(dir, npmBinaryName(deps.platform))) ? dir : null;
 }
 function highestVersionedNodeBin(installsDir, name) {
@@ -17189,8 +17642,8 @@ function probeOnnxRuntimeLoadable(libPath, arch = process.arch) {
 }
 // ../aft-bridge/dist/onnx-runtime.js
 import { createHash as createHash5, randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync as chmodSync2, closeSync as closeSync5, copyFileSync as copyFileSync2, createWriteStream as createWriteStream2, existsSync as existsSync11, lstatSync, mkdirSync as mkdirSync5, openSync as openSync5, readdirSync as readdirSync3, readFileSync as readFileSync8, readlinkSync, realpathSync as realpathSync3, renameSync as renameSync6, rmSync as rmSync3, statSync as statSync8, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute6, join as join14, relative as relative2, resolve as resolve8, win32 } from "node:path";
+import { chmodSync as chmodSync2, closeSync as closeSync5, copyFileSync as copyFileSync2, createWriteStream as createWriteStream2, existsSync as existsSync11, lstatSync, mkdirSync as mkdirSync5, openSync as openSync5, readdirSync as readdirSync3, readFileSync as readFileSync9, readlinkSync, realpathSync as realpathSync3, renameSync as renameSync6, rmSync as rmSync3, statSync as statSync9, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { basename as basename3, dirname as dirname8, isAbsolute as isAbsolute6, join as join14, relative as relative2, resolve as resolve8, win32 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 
@@ -17397,7 +17850,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
             abandoned = true;
           } else {
             try {
-              const ageMs = Date.now() - statSync8(stagingDir).mtimeMs;
+              const ageMs = Date.now() - statSync9(stagingDir).mtimeMs;
               abandoned = ageMs > STALE_LOCK_MS;
             } catch {
               abandoned = true;
@@ -17434,7 +17887,7 @@ var REQUIRED_ORT_MAJOR = 1;
 var REQUIRED_ORT_MIN_MINOR = 20;
 var INVALID_ORT_VERSION = "<invalid>";
 function parseOnnxVersionFromPath(value) {
-  const name = basename2(value);
+  const name = basename3(value);
   const semverish = name.match(/(?:^|[._-])(\d+\.\d+\.\d+(?:[-+][A-Za-z0-9.-]+)?)(?:\.(?:dylib|dll))?$/);
   if (semverish)
     return semverish[1].split(/[-+]/, 1)[0];
@@ -17639,7 +18092,7 @@ async function downloadFileWithCap(url, destPath) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES2) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES2}`);
     }
-    mkdirSync5(dirname7(destPath), { recursive: true });
+    mkdirSync5(dirname8(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, transformController) {
@@ -17673,7 +18126,7 @@ function validateExtractedTree(stagingRoot) {
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
-        const resolvedTarget = resolve8(dirname7(fullPath), linkTarget);
+        const resolvedTarget = resolve8(dirname8(fullPath), linkTarget);
         const rel = relative2(realRoot, resolvedTarget);
         if (rel.startsWith("..") || isAbsolute6(rel) || win32.isAbsolute(rel)) {
           throw new Error(`extracted symlink ${fullPath} points outside staging root: ${linkTarget}`);
@@ -17809,7 +18262,7 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       unlinkSync4(dst);
     } catch {}
     const dstForContainment = join14(targetRoot, link.name);
-    const resolvedTarget = resolve8(dirname7(dstForContainment), link.target);
+    const resolvedTarget = resolve8(dirname8(dstForContainment), link.target);
     if (!isPathInsideRoot(targetRoot, resolvedTarget)) {
       const message = `ONNX Runtime symlink ${link.name} points outside install dir: ${link.target}`;
       if (requiredLibs.has(link.name)) {
@@ -17861,9 +18314,9 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
 function readOnnxInstalledMeta(installDir) {
   const path = join14(installDir, ONNX_INSTALLED_META_FILE);
   try {
-    if (!statSync8(path).isFile())
+    if (!statSync9(path).isFile())
       return null;
-    const raw = readFileSync8(path, "utf8");
+    const raw = readFileSync9(path, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -17879,7 +18332,7 @@ function readOnnxInstalledMeta(installDir) {
 }
 function sha256File2(path) {
   const hash = createHash5("sha256");
-  hash.update(readFileSync8(path));
+  hash.update(readFileSync9(path));
   return hash.digest("hex");
 }
 function acquireLock(lockPath) {
@@ -17907,12 +18360,12 @@ ${new Date().toISOString()}
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
-    const raw = readFileSync8(lockPath, "utf8");
+    const raw = readFileSync9(lockPath, "utf8");
     const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
       owningPid = parsed;
-    lockMtimeMs = statSync8(lockPath).mtimeMs;
+    lockMtimeMs = statSync9(lockPath).mtimeMs;
   } catch {
     return tryClaim();
   }
@@ -17932,7 +18385,7 @@ function releaseLock(lockPath) {
   try {
     let owningPid = null;
     try {
-      const raw = readFileSync8(lockPath, "utf8");
+      const raw = readFileSync9(lockPath, "utf8");
       const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
       const parsed = Number.parseInt(firstLine, 10);
       if (Number.isFinite(parsed) && parsed > 0)
@@ -18623,7 +19076,7 @@ function formatSemanticIndexStatus(status, stage, error, backend) {
   return status;
 }
 // src/config.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9, renameSync as renameSync7, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10, renameSync as renameSync7, unlinkSync as unlinkSync5, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { isAbsolute as isAbsolute7, parse as parsePath, resolve as resolvePath } from "node:path";
 var import_comment_json = __toESM(require_src2(), 1);
@@ -23466,6 +23919,17 @@ var SemanticConfigSchema = object({
   max_input_tokens: number2().int().positive().optional(),
   max_files: number2().int().positive().optional()
 });
+var RerankConfigSchema = object({
+  backend: _enum(["off", "onnx", "remote", "synapse"]).optional(),
+  model: string2().trim().min(1).optional(),
+  endpoint: string2().trim().min(1).optional(),
+  api_key_env: string2().trim().min(1).optional(),
+  top_n: number2().int().positive().optional(),
+  timeout_ms: number2().int().positive().optional()
+});
+var SearchConfigSchema = object({
+  rerank: RerankConfigSchema.optional()
+});
 var LspExtensionSchema = string2().trim().min(1).refine((value) => value.replace(/^\.+/, "").length > 0, {
   message: "Extension must include characters other than leading dots"
 });
@@ -23611,6 +24075,7 @@ var AftConfigFieldsSchema = object({
   lsp: LspConfigSchema.optional(),
   url_fetch_allow_private: boolean2().optional(),
   semantic: SemanticConfigSchema.optional(),
+  search: SearchConfigSchema.optional(),
   auto_update: boolean2().optional(),
   bridge: BridgeConfigSchema.optional(),
   subc: SubcConfigSchema.optional(),
@@ -23855,7 +24320,7 @@ function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 })
   let tmpPath = null;
   let oldKeys = [];
   try {
-    const content = readFileSync9(configPath, "utf-8");
+    const content = readFileSync10(configPath, "utf-8");
     const rawConfig = import_comment_json.parse(content);
     if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) {
       return { migrated: false, oldKeys: [] };
@@ -23922,6 +24387,18 @@ function parseConfigPartially(rawConfig) {
   return partialConfig;
 }
 var configLoadErrors = [];
+var configValidationErrors = [];
+var configLoadSources = [];
+var configLoadTexts = new Map;
+function getConfigLoadSources() {
+  return configLoadSources;
+}
+function getConfigLoadTexts() {
+  return configLoadTexts;
+}
+function getConfigValidationErrors() {
+  return configValidationErrors;
+}
 function getConfigLoadErrors() {
   return configLoadErrors;
 }
@@ -23954,7 +24431,9 @@ function loadConfigFromPath(configPath, tier) {
     if (!existsSync12(configPath)) {
       return null;
     }
-    const content = readFileSync9(configPath, "utf-8");
+    const content = readFileSync10(configPath, "utf-8");
+    configLoadSources.push(configPath);
+    configLoadTexts.set(configPath, content);
     const rawConfig = import_comment_json.parse(content);
     migrateRawConfig(rawConfig, configPath, { log: log2, warn: warn2 });
     cleanConfig = stripJsoncSymbols(rawConfig);
@@ -23999,6 +24478,7 @@ function loadConfigFromPath(configPath, tier) {
   } else {
     const errorMsg = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
     warn2(`Config validation error in ${configPath}: ${errorMsg}`);
+    configValidationErrors.push({ path: configPath, message: errorMsg });
     parsed = parseConfigPartially(cleanConfig);
   }
   if (!parsed)
@@ -24195,14 +24675,33 @@ function getStrippedTopLevelKeys(override) {
   for (const tool of partitionProjectDisables(override.disabled_tools).ignored) {
     stripped.push(`disabled_tools.${tool}`);
   }
+  stripped.push(...projectRerankStrippedKeys(override.search?.rerank));
   return stripped;
 }
+function projectRerankStrippedKeys(rerank) {
+  if (rerank === undefined)
+    return [];
+  const stripped = [];
+  if (rerank.backend !== undefined && rerank.backend !== "off")
+    stripped.push("search.rerank.backend");
+  for (const key of ["model", "endpoint", "api_key_env", "top_n", "timeout_ms"]) {
+    if (rerank[key] !== undefined)
+      stripped.push(`search.rerank.${key}`);
+  }
+  return stripped;
+}
+function mergeProjectSearchConfig(base, project) {
+  if (project?.rerank?.backend !== "off")
+    return base;
+  return { ...base, rerank: { ...base?.rerank, backend: "off" } };
+}
 function mergeConfigs(base, override) {
   const disabledTools = unionDisabledTools(base.disabled_tools, partitionProjectDisables(override.disabled_tools).accepted);
   const indexes = mergeIndexes(base.indexes, override.indexes, true);
   const formatter = { ...base.formatter, ...override.formatter };
   const checker = { ...base.checker, ...override.checker };
   const semantic = mergeSemanticConfig(base.semantic, override.semantic);
+  const search = mergeProjectSearchConfig(base.search, override.search);
   const lsp = mergeLspConfig(base.lsp, override.lsp);
   const experimental = mergeExperimentalConfig(base.experimental, override.experimental);
   const bash = mergeBashConfig(base.bash, override.bash);
@@ -24232,6 +24731,7 @@ function mergeConfigs(base, override) {
     ...pi !== undefined ? { pi } : {},
     experimental,
     semantic,
+    search,
     ...bridge !== undefined ? { bridge } : {},
     ...indexes !== undefined ? { indexes } : {},
     ...disabledTools !== undefined ? { disabled_tools: disabledTools } : {}
@@ -24296,6 +24796,9 @@ function buildConfigTierConfigureParams(projectDirectory, processState = {}) {
 }
 function loadAftConfig(projectDirectory) {
   configLoadErrors = [];
+  configValidationErrors = [];
+  configLoadSources = [];
+  configLoadTexts = new Map;
   configLoadNotices = [];
   semanticInputSupplied = false;
   const { userConfigPath, projectConfigPath } = resolveAftConfigPaths(projectDirectory);
@@ -38128,16 +38631,29 @@ function markBridgeEnd() {
     slot.bridgeEnd = performance.now();
   }
 }
+async function measurePreStage(stage, operation) {
+  const start = performance.now();
+  try {
+    return await operation();
+  } finally {
+    const slot = perfStore.getStore();
+    if (slot) {
+      slot.stages ??= {};
+      slot.stages[stage] = (slot.stages[stage] ?? 0) + performance.now() - start;
+    }
+  }
+}
 function emit(slot) {
+  const stages = slot.stages ? ` directory=${Math.round(slot.stages.directory ?? 0)}ms permission=${Math.round(slot.stages.permission ?? 0)}ms capability=${Math.round(slot.stages.capability ?? 0)}ms` : "";
   const t3 = performance.now();
   const total = Math.round(t3 - slot.t0);
   if (slot.bridgeStart !== undefined && slot.bridgeEnd !== undefined) {
     const pre = Math.round(slot.bridgeStart - slot.t0);
     const bridge = Math.round(slot.bridgeEnd - slot.bridgeStart);
     const post = Math.round(t3 - slot.bridgeEnd);
-    sessionLog(slot.sessionID, `perf tool=${slot.tool} total=${total}ms pre=${pre}ms bridge=${bridge}ms post=${post}ms`);
+    sessionLog(slot.sessionID, `perf tool=${slot.tool} total=${total}ms pre=${pre}ms bridge=${bridge}ms post=${post}ms${stages}`);
   } else {
-    sessionLog(slot.sessionID, `perf tool=${slot.tool} total=${total}ms (no bridge call)`);
+    sessionLog(slot.sessionID, `perf tool=${slot.tool} total=${total}ms (no bridge call)${stages}`);
   }
 }
 function instrumentToolMap(tools) {
@@ -38367,10 +38883,10 @@ import {
   createReadStream as createReadStream2,
   existsSync as existsSync15,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   renameSync as renameSync9,
   rmSync as rmSync5,
-  statSync as statSync10,
+  statSync as statSync11,
   writeFileSync as writeFileSync8
 } from "node:fs";
 import { join as join17 } from "node:path";
@@ -38381,10 +38897,10 @@ import {
   closeSync as closeSync6,
   mkdirSync as mkdirSync6,
   openSync as openSync6,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   renameSync as renameSync8,
   rmSync as rmSync4,
-  statSync as statSync9,
+  statSync as statSync10,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync7
 } from "node:fs";
@@ -38407,7 +38923,7 @@ function lspBinDir(npmPackage) {
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync9(join15(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync10(join15(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -38435,9 +38951,9 @@ function writeInstalledMetaIn(installDir, version, sha256) {
 function readInstalledMetaIn(installDir) {
   const path = join15(installDir, INSTALLED_META_FILE);
   try {
-    if (!statSync9(path).isFile())
+    if (!statSync10(path).isFile())
       return null;
-    const raw = readFileSync10(path, "utf8");
+    const raw = readFileSync11(path, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
@@ -38506,12 +39022,12 @@ ${token}
   let owningPid = null;
   let lockMtimeMs = 0;
   try {
-    const raw = readFileSync10(lock, "utf8");
+    const raw = readFileSync11(lock, "utf8");
     const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
     const parsed = Number.parseInt(firstLine, 10);
     if (Number.isFinite(parsed) && parsed > 0)
       owningPid = parsed;
-    lockMtimeMs = statSync9(lock).mtimeMs;
+    lockMtimeMs = statSync10(lock).mtimeMs;
   } catch {
     return tryClaim();
   }
@@ -38545,7 +39061,7 @@ function releaseInstallLock(lockKey, acquisitionToken) {
     let owningPid = null;
     let owningToken = "";
     try {
-      const raw = readFileSync10(lock, "utf8");
+      const raw = readFileSync11(lock, "utf8");
       const lines = raw.split(/\r?\n/);
       const parsed = Number.parseInt(lines[0]?.trim() ?? "", 10);
       if (Number.isFinite(parsed) && parsed > 0)
@@ -38592,7 +39108,7 @@ function autoInstallStampPath() {
 }
 function hasRecentAutoInstallStamp(path) {
   try {
-    const parsed = JSON.parse(readFileSync10(path, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
     return typeof parsed.lastRunMs === "number" && Number.isFinite(parsed.lastRunMs) && Math.abs(Date.now() - parsed.lastRunMs) < AUTO_INSTALL_WINDOW_MS;
   } catch {
     return false;
@@ -38600,7 +39116,7 @@ function hasRecentAutoInstallStamp(path) {
 }
 function readAutoInstallLockOwner(path) {
   try {
-    const parsed = JSON.parse(readFileSync10(path, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
     if (typeof parsed.pid !== "number" || typeof parsed.startedMs !== "number" || typeof parsed.token !== "string") {
       return null;
     }
@@ -38613,7 +39129,7 @@ function autoInstallLockIsStale(path) {
   const owner = readAutoInstallLockOwner(path);
   let age = Number.POSITIVE_INFINITY;
   try {
-    age = Math.abs(Date.now() - statSync9(path).mtimeMs);
+    age = Math.abs(Date.now() - statSync10(path).mtimeMs);
   } catch {
     return true;
   }
@@ -38691,7 +39207,7 @@ var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
   const file = join15(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
-    const raw = readFileSync10(file, "utf8");
+    const raw = readFileSync11(file, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.last_checked === "string") {
       return {
@@ -38794,6 +39310,13 @@ var NPM_LSP_TABLE = [
     extensions: ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"],
     rootMarkers: ["tsconfig.json", "jsconfig.json", "package.json"]
   },
+  {
+    id: "typescript-sdk",
+    npm: "typescript",
+    binary: "tsserver",
+    extensions: ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"],
+    rootMarkers: ["tsconfig.json", "jsconfig.json", "package.json"]
+  },
   {
     id: "python",
     npm: "pyright",
@@ -38868,7 +39391,7 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync11 } from "node:fs";
+import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "node:fs";
 import { join as join16 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
@@ -38910,7 +39433,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync11(join16(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync12(join16(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -39258,7 +39781,7 @@ function hashInstalledBinary(spec) {
     let pathToHash = null;
     for (const p of candidates) {
       try {
-        if (statSync10(p).isFile()) {
+        if (statSync11(p).isFile()) {
           pathToHash = p;
           break;
         }
@@ -39284,14 +39807,14 @@ function installedBinaryPath(spec) {
   ] : [lspBinaryPath(spec.npm, spec.binary)];
   for (const candidate of candidates) {
     try {
-      if (statSync10(candidate).isFile())
+      if (statSync11(candidate).isFile())
         return candidate;
     } catch {}
   }
   return null;
 }
 function sha256OfFileSync(path) {
-  return createHash7("sha256").update(readFileSync12(path)).digest("hex");
+  return createHash7("sha256").update(readFileSync13(path)).digest("hex");
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
@@ -39334,7 +39857,7 @@ function runAutoInstall(projectRoot, config, fetchImpl = fetch) {
     if (isInstalled(spec.npm, spec.binary) && validateCachedNpmInstall(spec)) {
       cachedBinDirs.push(lspBinDir(spec.npm));
     }
-    if (config.disabled.has(spec.id)) {
+    if (config.disabled.has(spec.id) || spec.id === "typescript-sdk" && config.disabled.has("typescript")) {
       skipped.push({ id: spec.id, reason: "disabled by config" });
       continue;
     }
@@ -39390,16 +39913,16 @@ import {
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync8,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync4,
   renameSync as renameSync10,
   rmSync as rmSync6,
-  statSync as statSync11,
+  statSync as statSync12,
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { dirname as dirname8, join as join18, relative as relative3, resolve as resolve10 } from "node:path";
+import { dirname as dirname9, join as join18, relative as relative3, resolve as resolve10 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -39508,7 +40031,7 @@ function installFailureMarkerPath(spec) {
 }
 function readInstallFailureMarker(spec) {
   try {
-    const marker = JSON.parse(readFileSync13(installFailureMarkerPath(spec), "utf8"));
+    const marker = JSON.parse(readFileSync14(installFailureMarkerPath(spec), "utf8"));
     if (typeof marker.release !== "string" || typeof marker.sha256 !== "string" || typeof marker.error !== "string" || typeof marker.at !== "string" || !Number.isFinite(Date.parse(marker.at))) {
       return null;
     }
@@ -39522,7 +40045,7 @@ function writeInstallFailureMarker(spec, release, sha256, installError) {
   const markerError = installError.replace(/\s+/g, " ").trim();
   const tempPath = `${path}.tmp-${process.pid}-${randomBytes4(6).toString("hex")}`;
   try {
-    mkdirSync8(dirname8(path), { recursive: true });
+    mkdirSync8(dirname9(path), { recursive: true });
     writeFileSync9(tempPath, `${JSON.stringify({ release, sha256, error: markerError, at: new Date().toISOString() })}
 `, { encoding: "utf8", mode: 384 });
     renameSync10(tempPath, path);
@@ -39551,7 +40074,7 @@ function ghBinaryPath(spec, platform) {
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync11(join18(ghBinDir(spec), candidate)).isFile())
+      if (statSync12(join18(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -39565,9 +40088,9 @@ function ghBinaryCandidates(spec, platform) {
 function readGithubInstalledMetaIn(installDir) {
   try {
     const path = join18(installDir, INSTALLED_META_FILE2);
-    if (!statSync11(path).isFile())
+    if (!statSync12(path).isFile())
       return null;
-    const parsed = JSON.parse(readFileSync13(path, "utf8"));
+    const parsed = JSON.parse(readFileSync14(path, "utf8"));
     if (typeof parsed.version !== "string" || parsed.version.length === 0)
       return null;
     return {
@@ -39608,7 +40131,7 @@ function sha256OfFile(path) {
   });
 }
 function sha256OfFileSync2(path) {
-  return createHash8("sha256").update(readFileSync13(path)).digest("hex");
+  return createHash8("sha256").update(readFileSync14(path)).digest("hex");
 }
 async function fetchReleaseByTag(githubRepo, tag, fetchImpl, signal) {
   const candidates = [];
@@ -39784,7 +40307,7 @@ async function downloadFile(url, destPath, fetchImpl, assetSize, signal) {
     if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES3) {
       throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES3}`);
     }
-    mkdirSync8(dirname8(destPath), { recursive: true });
+    mkdirSync8(dirname9(destPath), { recursive: true });
     let bytesWritten = 0;
     const guard = new TransformStream({
       transform(chunk, controller) {
@@ -39954,7 +40477,7 @@ function quarantineCachedGithubInstall(spec, reason) {
   const dest = join18(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(dirname8(dest), { recursive: true });
+    mkdirSync8(dirname9(dest), { recursive: true });
     rmSync6(dest, { recursive: true, force: true });
     renameSync10(packageDir, dest);
   } catch (err) {
@@ -39966,7 +40489,7 @@ function validateCachedGithubInstall(spec, platform) {
   const meta = readGithubInstalledMetaIn(packageDir);
   const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join18(ghBinDir(spec), candidate)).find((candidate) => {
     try {
-      return statSync11(candidate).isFile();
+      return statSync12(candidate).isFile();
     } catch {
       return false;
     }
@@ -40084,7 +40607,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
     return { ok: false, sha256: archiveSha256, error: message };
   }
   const targetBinary = ghBinaryPath(spec, platform);
-  mkdirSync8(dirname8(targetBinary), { recursive: true });
+  mkdirSync8(dirname9(targetBinary), { recursive: true });
   try {
     copyFileSync3(innerBinaryPath, targetBinary);
     if (platform !== "win32") {
@@ -40613,14 +41136,16 @@ async function assertExternalDirectoryPermission(ctx, context, target, options)
   const directory = root ? normalizePath(root) : root;
   const rawWorktree = context.worktree;
   const worktree = rawWorktree && rawWorktree !== "/" ? normalizePath(rawWorktree) : rawWorktree;
+  const restrictToProjectRoot = ctx.config.restrict_to_project_root === true;
   if (directory && containsPath(directory, absoluteTarget))
     return;
-  if (worktree && worktree !== "/" && worktree !== directory && containsPath(worktree, absoluteTarget)) {
+  if (!restrictToProjectRoot && worktree && worktree !== "/" && worktree !== directory && containsPath(worktree, absoluteTarget)) {
     return;
   }
-  if (ctx.config.restrict_to_project_root === true) {
-    if (options?.serverValidatedRead === true)
+  if (restrictToProjectRoot) {
+    if (options?.serverValidatedRead === true && await isSessionOwnedBashArtifact(ctx, context, absoluteTarget)) {
       return;
+    }
     notifyRestrictBlocked(ctx, context, absoluteTarget);
     return restrictDenialMessage(absoluteTarget);
   }
@@ -41150,8 +41675,87 @@ function projectV2Tool(name, definition, location, consumers = {}) {
 }
 
 // src/tools/hoisted.ts
+import { stat as stat2 } from "node:fs/promises";
 import * as path4 from "node:path";
 
+// src/shared/read-vision.ts
+var VISION_HOST_TIMEOUT_MS = 1500;
+var states = new WeakMap;
+function stateFor2(client) {
+  let state = states.get(client);
+  if (!state) {
+    state = { models: new Map, history: new Map, capabilities: new Map };
+    states.set(client, state);
+  }
+  return state;
+}
+function rememberReadModel(client, sessionID, model) {
+  stateFor2(client).models.set(sessionID, model);
+}
+async function bounded(call) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve().then(call),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(undefined), VISION_HOST_TIMEOUT_MS);
+      })
+    ]);
+  } catch {
+    return;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function record3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+async function currentSessionVisionCapability(client, sessionID) {
+  if (!sessionID)
+    return;
+  const state = stateFor2(client);
+  let model = state.models.get(sessionID);
+  if (!model) {
+    let pending = state.history.get(sessionID);
+    if (!pending) {
+      pending = bounded(() => resolvePromptContext(client, sessionID)).then((context) => context?.model);
+      state.history.set(sessionID, pending);
+      pending.finally(() => state.history.delete(sessionID));
+    }
+    const historical = await pending;
+    model = state.models.get(sessionID) ?? historical;
+  }
+  if (!model)
+    return;
+  const currentModel = model;
+  const key = JSON.stringify([model.providerID, model.modelID]);
+  let capability = state.capabilities.get(key);
+  if (!capability) {
+    capability = (async () => {
+      const api = client.provider;
+      if (!api?.list)
+        return;
+      const list = api.list.bind(api);
+      const listed = record3(await bounded(list));
+      const catalog = record3(listed?.data) ?? listed;
+      const providers = catalog?.all ?? catalog?.providers;
+      if (!Array.isArray(providers))
+        return;
+      const provider = providers.map(record3).find((entry) => entry?.id === currentModel.providerID);
+      const models = provider?.models;
+      const entry = record3(Array.isArray(models) ? models.find((entry) => record3(entry)?.id === currentModel.modelID) : record3(models)?.[currentModel.modelID]);
+      const inputs = record3(entry?.modalities)?.input;
+      return Array.isArray(inputs) ? inputs.includes("image") : typeof entry?.attachment === "boolean" ? entry.attachment : undefined;
+    })();
+    state.capabilities.set(key, capability);
+    capability.then((value) => {
+      if (value === undefined)
+        state.capabilities.delete(key);
+    });
+  }
+  return capability;
+}
+
 // src/shared/subagent-detect.ts
 import { Effect as Effect2 } from "effect";
 var CACHE_MAX_ENTRIES2 = 200;
@@ -41738,7 +42342,7 @@ A notification will fire when the pattern matches or the task exits.`;
       const data = await waitForBashStatus(ctx, context, taskId, undefined, waitFor, effectiveWaitMs);
       const waited = data.waited;
       if (waited?.reason === "user_message") {
-        const convertedText = await convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, coerceBoolean(args.once, true));
+        const convertedText = await convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, coerceBoolean(args.once, true), waited.elapsed_ms);
         const metadata = context.metadata;
         metadata?.({ taskId, status: data.status, waited, convertedToAsync: true });
         return convertedText;
@@ -41750,9 +42354,10 @@ A notification will fire when the pattern matches or the task exits.`;
     }
   };
 }
-async function convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, once) {
+async function convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, once, elapsedMs) {
+  const interrupted = `Sync watch for task ${taskId} was interrupted because you sent a message after ${elapsedMs}ms of waiting. `;
   if (!waitFor) {
-    return `Sync watch for task ${taskId} was interrupted because you sent a message. ` + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits; don't poll bash_status.`;
+    return interrupted + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits; don't poll bash_status.`;
   }
   const notifyParams = {
     task_id: taskId,
@@ -41767,12 +42372,12 @@ async function convertToAsyncWatchOnAbort(ctx, context, taskId, waitFor, once) {
     const registered = await callBashBridge(ctx, context, "bash_notify", notifyParams);
     if (registered.success === false) {
       unmarkExplicitControl(context.sessionID, taskId);
-      return `Sync watch for task ${taskId} was interrupted because you sent a message. ` + `Auto-registering an async watch failed (${String(registered.message ?? "unknown error")}). ` + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits.`;
+      return interrupted + `Auto-registering an async watch failed (${String(registered.message ?? "unknown error")}). ` + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits.`;
     }
-    return `Sync watch for task ${taskId} was interrupted because you sent a message. ` + `The wait has been converted to an async watch (${registered.watch_id}). ` + `A notification will fire when the pattern matches or the task exits.`;
+    return interrupted + `The wait has been converted to an async watch (${registered.watch_id}). ` + `A notification will fire when the pattern matches or the task exits.`;
   } catch (err) {
     unmarkExplicitControl(context.sessionID, taskId);
-    return `Sync watch for task ${taskId} was interrupted because you sent a message. ` + `Auto-registering an async watch failed (${err instanceof Error ? err.message : String(err)}). ` + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits.`;
+    return interrupted + `Auto-registering an async watch failed (${err instanceof Error ? err.message : String(err)}). ` + `The task is still running in the background. A completion reminder will be ` + `delivered automatically when the task exits.`;
   }
 }
 function formatWatchResultText(taskId, data, waited, role, syncWaitCap) {
@@ -41781,21 +42386,22 @@ function formatWatchResultText(taskId, data, waited, role, syncWaitCap) {
   const dur = typeof data.duration_ms === "number" ? ` ${Math.round(data.duration_ms / 1000)}s` : "";
   let text = `Task ${taskId}: ${status}${exit}${dur}`;
   if (waited) {
+    const waitedText = formatWatchWaited(waited.elapsed_ms, waited.limit_ms, syncWaitCap);
     if (waited.reason === "matched") {
       const stream = waited.match_stream ? ` in ${waited.match_stream}` : "";
       text += `
-Waited ${waited.elapsed_ms}ms; matched ${JSON.stringify(waited.match ?? "")}${stream} at offset ${waited.match_offset ?? 0}.`;
+${waitedText}; matched ${JSON.stringify(waited.match ?? "")}${stream} at offset ${waited.match_offset ?? 0}.`;
     } else if (waited.reason === "timeout") {
       text += `
-Waited ${waited.elapsed_ms}ms; timeout reached without match. ${watchTimeoutSteer(role, syncWaitCap)}`;
+${waitedText}; timeout reached without match. ${watchTimeoutSteer(role, syncWaitCap)}`;
     } else if (waited.reason === "unavailable") {
       text += `
-Waited ${waited.elapsed_ms}ms; the bridge was busy, so task state is unknown. Do not poll; let the task's completion notification wake the session, or use one bash_status snapshot on the next normal tool call.`;
+${waitedText}; the bridge was busy, so task state is unknown. Do not poll; let the task's completion notification wake the session, or use one bash_status snapshot on the next normal tool call.`;
     } else {
       const stat = String(data.status ?? "unknown");
       const e = typeof data.exit_code === "number" ? `, exit ${data.exit_code}` : "";
       text += `
-Waited ${waited.elapsed_ms}ms; task exited (${stat}${e}).`;
+${waitedText}; task exited (${stat}${e}).`;
     }
   }
   const preview = data.output_preview;
@@ -41817,8 +42423,9 @@ async function bashStatusSnapshot2(ctx, runtime, taskId, outputMode, cursor, opt
   return data;
 }
 async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effectiveWaitMs) {
-  const startedAt = Date.now();
+  const startedAt = monotonicNowMs();
   const deadline = startedAt + effectiveWaitMs;
+  const elapsedMs = () => Math.round(monotonicNowMs() - startedAt);
   let spillCursor = { output: 0, stderr: 0 };
   const scanState = {
     output: { text: "", baseOffset: 0 },
@@ -41843,16 +42450,18 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
         if (isSyncWatchAborted(runtime.sessionID)) {
           return withWaited(lastData ?? unavailableSnapshot(), {
             reason: "user_message",
-            elapsed_ms: Date.now() - startedAt
+            elapsed_ms: elapsedMs(),
+            limit_ms: effectiveWaitMs
           });
         }
-        if (Date.now() >= deadline) {
+        if (monotonicNowMs() >= deadline) {
           return withWaited(lastData ?? unavailableSnapshot(), {
             reason: "unavailable",
-            elapsed_ms: Date.now() - startedAt
+            elapsed_ms: elapsedMs(),
+            limit_ms: effectiveWaitMs
           });
         }
-        await sleep(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+        await sleep(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - monotonicNowMs())));
         continue;
       }
       lastData = data;
@@ -41881,7 +42490,8 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
               const matchStream = data.mode === "pty" ? undefined : chunk.stream === "output" ? "stdout" : "stderr";
               return withWaited(data, {
                 reason: "matched",
-                elapsed_ms: Date.now() - startedAt,
+                elapsed_ms: elapsedMs(),
+                limit_ms: effectiveWaitMs,
                 match: match.text,
                 match_offset: state.baseOffset + match.byteOffset,
                 match_stream: matchStream
@@ -41899,15 +42509,27 @@ async function waitForBashStatus(ctx, runtime, taskId, outputMode, waitFor, effe
         sawTerminal = true;
         consumeBgCompletion(runtime.sessionID, taskId);
         await markBgCompletionDelivered({ ctx, directory: projectRootFor(runtime), sessionID: runtime.sessionID }, taskId);
-        return withWaited(data, { reason: "exited", elapsed_ms: Date.now() - startedAt });
+        return withWaited(data, {
+          reason: "exited",
+          elapsed_ms: elapsedMs(),
+          limit_ms: effectiveWaitMs
+        });
       }
       if (isSyncWatchAborted(runtime.sessionID)) {
-        return withWaited(data, { reason: "user_message", elapsed_ms: Date.now() - startedAt });
+        return withWaited(data, {
+          reason: "user_message",
+          elapsed_ms: elapsedMs(),
+          limit_ms: effectiveWaitMs
+        });
       }
-      if (Date.now() >= deadline) {
-        return withWaited(data, { reason: "timeout", elapsed_ms: Date.now() - startedAt });
+      if (monotonicNowMs() >= deadline) {
+        return withWaited(data, {
+          reason: "timeout",
+          elapsed_ms: elapsedMs(),
+          limit_ms: effectiveWaitMs
+        });
       }
-      await sleep(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+      await sleep(Math.min(BASH_WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - monotonicNowMs())));
     }
   } finally {
     if (!sawTerminal)
@@ -42055,47 +42677,6 @@ var ISSUE_AND_PR_READ_DESCRIPTION = "GitHub issues and pull requests can be read
 function whenGhReadEnabled(enabled, description) {
   return enabled ? description : "";
 }
-function asRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
-}
-function visionCapabilityForOpenCodeModel(model) {
-  const entry = model;
-  if (Array.isArray(entry?.modalities?.input)) {
-    return entry.modalities.input.includes("image");
-  }
-  return typeof entry?.attachment === "boolean" ? entry.attachment : undefined;
-}
-function modelFromOpenCodeProvider(provider, modelID) {
-  const models = provider.models;
-  if (Array.isArray(models)) {
-    return models.find((model) => asRecord(model)?.id === modelID);
-  }
-  return asRecord(models)?.[modelID];
-}
-async function currentSessionVisionCapability(client, sessionID) {
-  if (!sessionID)
-    return;
-  const promptContext = await resolvePromptContext(client, sessionID);
-  const currentModel = promptContext?.model;
-  if (!currentModel)
-    return;
-  const providerApi = client.provider;
-  if (typeof providerApi?.list !== "function")
-    return;
-  let listed;
-  try {
-    listed = await providerApi.list();
-  } catch {
-    return;
-  }
-  const result = asRecord(listed);
-  const catalog = asRecord(result?.data) ?? result;
-  const providers = Array.isArray(catalog?.all) ? catalog.all : Array.isArray(catalog?.providers) ? catalog.providers : [];
-  const provider = providers.map(asRecord).find((entry) => entry?.id === currentModel.providerID);
-  if (!provider)
-    return;
-  return visionCapabilityForOpenCodeModel(modelFromOpenCodeProvider(provider, currentModel.modelID));
-}
 function persistFilePathAlias(args, context) {
   if (typeof args.path === "string" && !Object.hasOwn(args, "filePath")) {
     args.filePath = args.path;
@@ -42267,7 +42848,7 @@ function inferBeforeStart(ops, from, beforeLen) {
 var z7 = tool.schema;
 var READ_DESCRIPTION = `Read file contents or list directory entries.
 
-Use either startLine/endLine OR offset/limit to read a section of a file.
+Use either startLine/endLine OR offset/limit to read a section of a file or sorted directory listing.
 
 Behavior:
 - Returns line-numbered content (e.g., "1: const x = 1")
@@ -42275,7 +42856,7 @@ Behavior:
 - Output capped at 50KB
 - Binary files are auto-detected and return a size-only message
 - Supported images (PNG, JPEG, GIF, WebP) and PDFs are returned as tool attachments; range arguments are ignored for media
-- Directories return sorted entries with trailing / for subdirectories
+- Directories return sorted entries with trailing / for subdirectories; offset is 1-based, limit defaults to and is capped at 1000 entries. Enumeration stops at 10,000 entries; partial listings carry a shown/total trailer.
 
 Examples:
   Read full file: { "path": "src/app.ts" }
@@ -42299,30 +42880,30 @@ function createReadTool(ctx) {
       description: readDescription(resolveGithubConfig(ctx.config).read),
       args: {
         filePath: z7.string().describe("Path to file or directory (absolute or relative to project root)"),
-        startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to start reading from"),
-        endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to stop reading at (inclusive)"),
-        limit: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max lines to return (default: 2000)"),
-        offset: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line number to start reading from (use with limit). Ignored if startLine is provided")
+        startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to start reading from"),
+        endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to stop reading at (inclusive)"),
+        limit: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max lines (default: 2000) or directory entries (default and cap: 1000) to return"),
+        offset: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line or directory entry to start reading from (use with limit). Ignored if startLine is provided")
       },
       execute: async (args, context) => {
         const file = args.path;
-        const projectRoot = await resolveProjectRoot(ctx, context);
+        const projectRoot = await measurePreStage("directory", () => resolveProjectRoot(ctx, context));
         const filePath = resolvePathFromProjectRoot(projectRoot, file);
         persistFilePathAlias(args, context);
         {
-          const denial = await assertExternalDirectoryPermission(ctx, context, filePath, {
+          const denial = await measurePreStage("permission", () => assertExternalDirectoryPermission(ctx, context, filePath, {
             serverValidatedRead: true
-          });
+          }));
           if (denial)
             return permissionDeniedResponse(denial);
         }
         try {
-          await runAsk(context.ask({
+          await measurePreStage("permission", () => runAsk(context.ask({
             permission: "read",
             patterns: [permissionPath(context, filePath)],
             always: ["*"],
             metadata: {}
-          }));
+          })));
         } catch (error) {
           const failure = classifyPermissionError(error);
           return permissionDeniedResponse(failure.kind === "rule_denied" ? permissionRuleDenial("read") : failure.message);
@@ -42346,7 +42927,8 @@ function createReadTool(ctx) {
           rawArgs.endLine = endLine;
         if (rawLimit !== undefined && rawOffset === undefined)
           rawArgs.limit = rawLimit;
-        const visionCapability = await currentSessionVisionCapability(ctx.client, context.sessionID);
+        const mediaCandidate = isGithubResourcePath(file) || /\.(png|jpe?g|gif|webp|pdf)$/i.test(filePath) && await stat2(filePath).then((info) => info.isFile(), () => false);
+        const visionCapability = mediaCandidate ? await measurePreStage("capability", () => currentSessionVisionCapability(ctx.client, context.sessionID)) : undefined;
         if (visionCapability !== undefined)
           rawArgs.vision_capability = visionCapability;
         const response = await callToolCall(ctx, context, "read", rawArgs);
@@ -42790,7 +43372,7 @@ function createApplyPatchTool(ctx) {
   };
 }
 function deleteDescription(ctx) {
-  const backupText = ctx.config.backup?.enabled === false ? "Backup capture is disabled by user config, so this tool does not create undo snapshots. " : "Each file is backed up before deletion — use aft_safety undo to recover any of them. For directories, every file inside is individually backed up before the tree is removed. The deleted file's contents stay in the undo store until its retention expires. A recursive delete whose backup would copy more than 2,000 files or 100 MiB in one call is refused before anything is deleted; delete such a tree in smaller pieces, or use bash `rm -rf` when no undo is needed. ";
+  const backupText = ctx.config.backup?.enabled === false ? "Backup capture is disabled by user config, so this tool does not create undo snapshots. A directory tree containing a mount point of another filesystem is still refused. " : "Each file is backed up before deletion — use aft_safety undo to recover any of them. A recursive delete backs up the whole tree: directories (empty ones too, with their permissions), file contents, hard links (relinked by undo) and symlinks (the link itself, never its target; restored exactly, even when dangling). Sockets are deleted but undo does not restore them, and a file hard-linked to paths outside the tree comes back as an independent copy; both are reported as warnings. Refused before anything is deleted: mount points of another filesystem, named pipes, device nodes, and symlinks undo cannot recreate exactly (non-UTF-8 target, or on Windows). Paths under the system temp directory are never backed up, so only mount points are refused there. The deleted file's contents stay in the undo store until its retention expires. A recursive delete whose backup would record more than 2,000 entries (files, directories and links) or copy 100 MiB in one call is refused before anything is deleted; delete such a tree in smaller pieces, or use bash `rm -rf` when no undo is needed. ";
   return `Delete one or more files (or directories).
 
 ` + backupText + `Directory deletion requires recursive: true. Without it, passing a directory returns an error.
@@ -43006,7 +43588,7 @@ async function resolveAndGateScope(ctx, context, scope) {
   }
   return { scope: Array.isArray(scope) ? resolved : resolved[0] };
 }
-function asRecord2(value) {
+function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
 function asString(value) {
@@ -43014,7 +43596,7 @@ function asString(value) {
 }
 function firstRecord(...values) {
   for (const value of values) {
-    const record = asRecord2(value);
+    const record = asRecord(value);
     if (record)
       return record;
   }
@@ -43049,7 +43631,7 @@ function parseInspectPhaseEntries(value) {
   if (!Array.isArray(value))
     return [];
   return value.flatMap((candidate) => {
-    const entry = asRecord2(candidate);
+    const entry = asRecord(candidate);
     const id = asString(entry?.id);
     if (!id)
       return [];
@@ -43065,7 +43647,7 @@ function parseInspectPhaseEntries(value) {
   });
 }
 function parseInspectTerminal(payload) {
-  const response = asRecord2(payload);
+  const response = asRecord(payload);
   if (!response)
     return;
   const kind = terminalKind(response);
@@ -43080,7 +43662,7 @@ function parseInspectTerminal(payload) {
       waitStampText: kind === "FRESH" ? firstString(waitStamp?.text, waitStamp?.human_text) : undefined
     };
   }
-  const failedPhaseRecord = asRecord2(response.failed_phase);
+  const failedPhaseRecord = asRecord(response.failed_phase);
   const failedPhaseId = firstString(failedPhaseRecord?.id, response.failed_phase);
   const failedPhase = failedPhaseId ? parseInspectPhaseEntries([
     {
@@ -43853,7 +44435,7 @@ function hasMeaningfulProjectSearchFallback(query, pathArg, externalRoot) {
   return trimmedQuery.length > 0 && trimmedQuery !== pathArg && trimmedQuery !== externalRoot;
 }
 var GENERATION_CHANGED_DISCLOSURE = "index changed - order re-derived";
-function asRecord3(value) {
+function asRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
 }
 function normalizeContinuityQuery(query) {
@@ -43868,14 +44450,14 @@ function continuityKey(projectRoot, query, includeTests, topK) {
   ]);
 }
 function responseGeneration(response) {
-  const envelope = asRecord3(response);
-  const structured = asRecord3(envelope?.structuredContent) ?? asRecord3(envelope?.structured_content);
-  const plan = asRecord3(envelope?.plan) ?? asRecord3(structured?.plan);
+  const envelope = asRecord2(response);
+  const structured = asRecord2(envelope?.structuredContent) ?? asRecord2(envelope?.structured_content);
+  const plan = asRecord2(envelope?.plan) ?? asRecord2(structured?.plan);
   const generation = plan?.snapshot_generation ?? envelope?.snapshot_generation;
   return typeof generation === "string" ? generation : undefined;
 }
 function surfaceSearchText(response, continuity, sessionId, key) {
-  const envelope = asRecord3(response);
+  const envelope = asRecord2(response);
   const text = typeof envelope?.text === "string" ? envelope.text : "";
   const generation = responseGeneration(response);
   if (generation === undefined)
@@ -44153,6 +44735,8 @@ var defaultBridgeBootstrapDependencies = {
   loadConfig: loadAftConfig,
   deliverLoadNotices: (notify) => deliverConfigLoadNotices(notify, getConfigLoadNotices()),
   configLoadErrors: getConfigLoadErrors,
+  configLoadSources: getConfigLoadSources,
+  configLoadTexts: getConfigLoadTexts,
   subcConnectionFileError,
   migrateConfigLocations: (directory) => migrateAftConfigLocations(directory, bridgeLogger).flatMap((result) => result.warnings),
   resolveBinary: resolveBinaryWithWarmup,
@@ -44194,8 +44778,12 @@ function loadBootstrapConfig(directory, notify, dependencies = defaultBridgeBoot
     const failure = parseFailure(dependencies);
     if (failure)
       return configErrorState(failure, notify);
+    const provenance = dependencies.configLoadSources ? {
+      sources: [...dependencies.configLoadSources()],
+      sourceTexts: Object.fromEntries(dependencies.configLoadTexts?.() ?? [])
+    } : {};
     dependencies.deliverLoadNotices?.(notify);
-    return { ok: true, config };
+    return { ok: true, config, ...provenance };
   } catch (err) {
     return configErrorState(err instanceof Error ? err.message : String(err), notify);
   }
@@ -44387,8 +44975,60 @@ function buildConfigErrorToolMap(config, message, client, buildToolMap = buildAf
   return failEveryToolCall(buildToolMap(ctx, config), message);
 }
 
+// src/config-live-reload.ts
+var OPENCODE_LIVE_CONFIG_KEYS = aftLiveConfigKeys((config) => resolveBashConfig(config));
+function projectTextOf(directory) {
+  const { projectConfigPath } = resolveCortexKitConfigPaths(directory);
+  return getConfigLoadTexts().get(projectConfigPath) ?? null;
+}
+function loadOpenCodeConfigForLiveReload(directory) {
+  try {
+    const config = loadAftConfig(directory);
+    const [failure] = getConfigLoadErrors();
+    if (failure) {
+      return { ok: false, message: formatConfigParseErrorMessage(failure.path, failure.message) };
+    }
+    const [invalid] = getConfigValidationErrors();
+    if (invalid) {
+      return {
+        ok: false,
+        message: `AFT config at ${invalid.path} has an invalid setting: ${invalid.message}`
+      };
+    }
+    return {
+      ok: true,
+      config,
+      sources: [...getConfigLoadSources()],
+      projectText: projectTextOf(directory),
+      texts: Object.fromEntries(getConfigLoadTexts())
+    };
+  } catch (err) {
+    return { ok: false, message: err instanceof Error ? err.message : String(err) };
+  }
+}
+function startOpenCodeLiveConfigReload(options) {
+  const { userConfigPath, projectConfigPath } = resolveCortexKitConfigPaths(options.directory);
+  return startLiveConfigReload({
+    paths: [userConfigPath, projectConfigPath],
+    load: () => loadOpenCodeConfigForLiveReload(options.directory),
+    initialSources: options.initialSources,
+    initialProjectText: options.initialSourceTexts?.[projectConfigPath] ?? null,
+    initialTexts: options.initialSourceTexts,
+    securityKeys: aftLiveSecurityKeys(OPENCODE_LIVE_CONFIG_KEYS),
+    keys: OPENCODE_LIVE_CONFIG_KEYS,
+    getConfig: options.getConfig,
+    setConfig: options.setConfig,
+    log: (message) => log2(`${message} (${options.directory})`),
+    reportError: (message) => {
+      error2(message);
+      options.notify(message);
+    },
+    watch: options.watch
+  });
+}
+
 // src/notifications.ts
-import { existsSync as existsSync18, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync15 } from "node:fs";
 import { homedir as homedir13, platform } from "node:os";
 import { join as join20 } from "node:path";
 function isTuiMode() {
@@ -44430,7 +45070,7 @@ function readDesktopState() {
     return { serverUrl: null };
   }
   try {
-    const raw = readFileSync14(statePath, "utf-8");
+    const raw = readFileSync15(statePath, "utf-8");
     const state = JSON.parse(raw);
     let serverUrl = null;
     const serverStr = state.server;
@@ -44929,23 +45569,25 @@ import {
   existsSync as existsSync21,
   mkdirSync as mkdirSync9,
   openSync as openSync7,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   renameSync as renameSync11,
   rmSync as rmSync8,
-  statSync as statSync14,
+  statSync as statSync15,
   writeFileSync as writeFileSync12
 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
-import { cpSync, existsSync as existsSync20, mkdtempSync, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { cpSync, existsSync as existsSync20, mkdtempSync, readFileSync as readFileSync17, rmSync as rmSync7, writeFileSync as writeFileSync11 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename5, dirname as dirname13, join as join23 } from "node:path";
+import { basename as basename6, dirname as dirname14, join as join23 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
-import { existsSync as existsSync19, readFileSync as readFileSync15, statSync as statSync13, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname12, isAbsolute as isAbsolute11, join as join22, resolve as resolve13 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync16, statSync as statSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { homedir as homedir14 } from "node:os";
+import { dirname as dirname13, isAbsolute as isAbsolute11, join as join22, resolve as resolve13 } from "node:path";
 import { fileURLToPath } from "node:url";
 var import_comment_json2 = __toESM(require_src2(), 1);
 
@@ -45036,14 +45678,14 @@ function resolvePathPluginSpec(spec, configPath) {
   }
   if (isAbsolute11(spec) || /^[A-Za-z]:[\\/]/.test(spec))
     return spec;
-  return resolve13(dirname12(configPath), spec);
+  return resolve13(dirname13(configPath), spec);
 }
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
       if (!existsSync19(configPath))
         continue;
-      const rawConfig = parseJsonConfig(readFileSync15(configPath, "utf-8"));
+      const rawConfig = parseJsonConfig(readFileSync16(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))
@@ -45053,7 +45695,7 @@ function getLocalDevPath(directory) {
           const pkgPath = findPackageJsonUp(localPath);
           if (!pkgPath)
             continue;
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync15(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync16(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return localPath;
         }
@@ -45064,18 +45706,18 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = statSync13(startPath);
-    let dir = stat.isDirectory() ? startPath : dirname12(startPath);
+    const stat = statSync14(startPath);
+    let dir = stat.isDirectory() ? startPath : dirname13(startPath);
     for (let i = 0;i < 10; i++) {
       const pkgPath = join22(dir, "package.json");
       if (existsSync19(pkgPath)) {
         try {
-          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync15(pkgPath, "utf-8")));
+          const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync16(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
             return pkgPath;
         } catch {}
       }
-      const parent = dirname12(dir);
+      const parent = dirname13(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -45091,7 +45733,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync15(pkgPath, "utf-8")));
+    const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync16(pkgPath, "utf-8")));
     return pkg.success ? pkg.data.version ?? null : null;
   } catch {
     return null;
@@ -45099,7 +45741,7 @@ function getLocalDevVersion(directory) {
 }
 function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
   try {
-    return findPackageJsonUp(dirname12(fileURLToPath(currentModuleUrl)));
+    return findPackageJsonUp(dirname13(fileURLToPath(currentModuleUrl)));
   } catch (err) {
     warn2(`[auto-update-checker] Failed to resolve runtime package path: ${String(err)}`);
     return null;
@@ -45110,7 +45752,7 @@ function findPluginEntry(directory) {
     try {
       if (!existsSync19(configPath))
         continue;
-      const rawConfig = parseJsonConfig(readFileSync15(configPath, "utf-8"));
+      const rawConfig = parseJsonConfig(readFileSync16(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
       for (const entry of plugins) {
         if (entry === PACKAGE_NAME) {
@@ -45143,7 +45785,7 @@ function getCachedVersion(spec) {
     try {
       if (!existsSync19(packageJsonPath))
         continue;
-      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync15(packageJsonPath, "utf-8")));
+      const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync16(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
         if (!spec)
           cachedPackageVersion = pkg.data.version;
@@ -45153,6 +45795,117 @@ function getCachedVersion(spec) {
   }
   return null;
 }
+var registryCache = new Map;
+function npmConfigGet(key, directory) {
+  return new Promise((resolve, reject) => {
+    execFile(process.platform === "win32" ? "npm.cmd" : "npm", ["config", "get", key], {
+      cwd: directory,
+      timeout: NPM_FETCH_TIMEOUT,
+      windowsHide: true,
+      shell: process.platform === "win32"
+    }, (error, stdout) => {
+      if (error)
+        reject(error);
+      else
+        resolve(stdout.trim());
+    });
+  });
+}
+function configuredRegistry(value) {
+  return value && value !== "undefined" && value !== "null" ? value : undefined;
+}
+async function readRegistrySettings(path, required = false) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    if (!required && error.code === "ENOENT")
+      return {};
+    throw error;
+  }
+  const settings = {};
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith(";"))
+      continue;
+    const separator = trimmed.indexOf("=");
+    if (separator < 0)
+      continue;
+    const key = trimmed.slice(0, separator).trim();
+    if (key === "registry" || key === "@cortexkit:registry") {
+      settings[key] = configuredRegistry(trimmed.slice(separator + 1).trim());
+    }
+  }
+  return settings;
+}
+function registryEnvironment(key) {
+  const variable = `npm_config_${key}`;
+  const value = process.env[variable] ?? Object.entries(process.env).find(([name]) => name.toLowerCase() === variable)?.[1];
+  return configuredRegistry(value ?? "");
+}
+async function registryWithoutNpm(directory) {
+  let scoped = registryEnvironment("@cortexkit:registry");
+  let registry = registryEnvironment("registry");
+  const visited = new Set;
+  for (let current = directory;; current = dirname13(current)) {
+    if (scoped)
+      break;
+    const path = join22(current, ".npmrc");
+    visited.add(path);
+    const settings = await readRegistrySettings(path);
+    scoped ??= settings["@cortexkit:registry"];
+    registry ??= settings.registry;
+    if (dirname13(current) === current)
+      break;
+  }
+  const explicitUserConfig = process.env.npm_config_userconfig ?? process.env.NPM_CONFIG_USERCONFIG;
+  const home = (process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME) ?? homedir14();
+  const userConfig = explicitUserConfig ?? join22(home, ".npmrc");
+  if (!scoped && !visited.has(userConfig)) {
+    const settings = await readRegistrySettings(userConfig, explicitUserConfig !== undefined);
+    scoped = settings["@cortexkit:registry"];
+    registry ??= settings.registry;
+  }
+  const selected = scoped ?? registry ?? NPM_REGISTRY_URL;
+  return selected.replace(/\$\{([^}]+)\}/g, (_match, name) => {
+    const value = process.env[name];
+    if (value === undefined)
+      throw new Error("Unresolved registry environment variable");
+    return value;
+  });
+}
+function validateRegistry(registry) {
+  const url = new URL(registry);
+  if (url.protocol !== "https:" && url.protocol !== "http:")
+    throw new Error("Unsupported registry protocol");
+  return registry;
+}
+var reportedRegistryFailures = new Set;
+function reportRegistryFailure(directory) {
+  const key = resolve13(directory);
+  if (reportedRegistryFailures.has(key))
+    return;
+  reportedRegistryFailures.add(key);
+  debug2("[auto-update-checker] Configured npm registry could not be resolved or used; skipping update check.");
+}
+function resolveRegistry(directory) {
+  const key = resolve13(directory);
+  let pending = registryCache.get(key);
+  if (!pending) {
+    pending = (async () => {
+      let registry;
+      try {
+        const scoped = configuredRegistry(await npmConfigGet("@cortexkit:registry", key));
+        registry = scoped ?? configuredRegistry(await npmConfigGet("registry", key)) ?? NPM_REGISTRY_URL;
+      } catch {
+        registry = await registryWithoutNpm(key);
+      }
+      return validateRegistry(registry);
+    })();
+    registryCache.set(key, pending);
+  }
+  return pending;
+}
 function buildRegistryUrl(registryUrl) {
   return `${registryUrl.replace(/\/+$/, "")}/${encodeURIComponent(PACKAGE_NAME).replace("%2F", "/")}`;
 }
@@ -45164,17 +45917,24 @@ async function getLatestVersion(channel = "latest", options = {}) {
   try {
     if (options.signal?.aborted)
       return null;
-    const response = await fetch(buildRegistryUrl(options.registryUrl ?? NPM_REGISTRY_URL), {
+    const registry = validateRegistry(options.registryUrl ?? await resolveRegistry(options.directory ?? process.cwd()));
+    if (controller.signal.aborted)
+      return null;
+    const response = await fetch(buildRegistryUrl(registry), {
       signal: controller.signal,
       headers: { Accept: "application/json" }
     });
-    if (!response.ok)
+    if (!response.ok) {
+      reportRegistryFailure(options.directory ?? process.cwd());
       return null;
+    }
     const data = NpmPackageEnvelopeSchema.safeParse(await response.json());
     if (!data.success)
       return null;
     return data.data["dist-tags"][channel] ?? data.data["dist-tags"].latest ?? null;
   } catch {
+    if (!controller.signal.aborted)
+      reportRegistryFailure(options.directory ?? process.cwd());
     return null;
   } finally {
     options.signal?.removeEventListener("abort", abortHandler);
@@ -45194,9 +45954,9 @@ function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
     packageJsonPath,
-    packageJson: existsSync20(packageJsonPath) ? readFileSync16(packageJsonPath, "utf-8") : null,
+    packageJson: existsSync20(packageJsonPath) ? readFileSync17(packageJsonPath, "utf-8") : null,
     lockfilePath,
-    lockfile: existsSync20(lockfilePath) ? readFileSync16(lockfilePath, "utf-8") : null,
+    lockfile: existsSync20(lockfilePath) ? readFileSync17(lockfilePath, "utf-8") : null,
     packageDir,
     stagedPackageDir,
     tempDir
@@ -45223,9 +45983,9 @@ function restoreAutoUpdateSnapshot(snapshot) {
 function stripPackageNameFromPath(pathValue, packageName) {
   let current = pathValue;
   for (const segment of [...packageName.split("/")].reverse()) {
-    if (basename5(current) !== segment)
+    if (basename6(current) !== segment)
       return null;
-    current = dirname13(current);
+    current = dirname14(current);
   }
   return current;
 }
@@ -45234,7 +45994,7 @@ function removeFromPackageLock(installDir, packageName) {
   if (!existsSync20(lockPath))
     return false;
   try {
-    const lock = import_comment_json3.parse(readFileSync16(lockPath, "utf-8"));
+    const lock = import_comment_json3.parse(readFileSync17(lockPath, "utf-8"));
     let modified = false;
     if (lock.packages) {
       const key = `node_modules/${packageName}`;
@@ -45260,7 +46020,7 @@ function ensureDependencyVersion(packageJsonPath, packageName, version) {
   if (!existsSync20(packageJsonPath))
     return false;
   try {
-    const raw = import_comment_json3.parse(readFileSync16(packageJsonPath, "utf-8"));
+    const raw = import_comment_json3.parse(readFileSync17(packageJsonPath, "utf-8"));
     const pkgJson = PackageJsonSchema.safeParse(raw);
     if (!pkgJson.success)
       return false;
@@ -45295,17 +46055,17 @@ function removeInstalledPackage(installDir, packageName) {
 }
 function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackageJsonPath()) {
   if (runtimePackageJsonPath) {
-    const packageDir = dirname13(runtimePackageJsonPath);
+    const packageDir = dirname14(runtimePackageJsonPath);
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
-    if (nodeModulesDir && basename5(nodeModulesDir) === "node_modules") {
-      const installDir = dirname13(nodeModulesDir);
+    if (nodeModulesDir && basename6(nodeModulesDir) === "node_modules") {
+      const installDir = dirname14(nodeModulesDir);
       const packageJsonPath = join23(installDir, "package.json");
       if (existsSync20(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
-  const cacheRoot = dirname13(cacheDir());
+  const cacheRoot = dirname14(cacheDir());
   const legacyPackageJsonPath = join23(cacheRoot, "package.json");
   if (existsSync20(legacyPackageJsonPath)) {
     return { installDir: cacheRoot, packageJsonPath: legacyPackageJsonPath };
@@ -45508,7 +46268,7 @@ function claimCheckSlot(storageDir, intervalMs) {
   try {
     if (hasRecentCheckTimestamp(file, intervalMs))
       return null;
-    mkdirSync9(dirname14(file), { recursive: true });
+    mkdirSync9(dirname15(file), { recursive: true });
     const lockPath = `${file}.lock`;
     const owner = { pid: process.pid, startedMs: Date.now() };
     let lockFd = null;
@@ -45579,9 +46339,9 @@ function isOrphanedCheckLock(lockPath) {
   }
 }
 function readCheckLockState(lockPath) {
-  const fallbackStartedMs = statSync14(lockPath).mtimeMs;
+  const fallbackStartedMs = statSync15(lockPath).mtimeMs;
   try {
-    const parsed = JSON.parse(readFileSync17(lockPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync18(lockPath, "utf-8"));
     const pid = Number.isSafeInteger(parsed.pid) && (parsed.pid ?? 0) > 0 ? parsed.pid ?? null : null;
     const startedMs = typeof parsed.startedMs === "number" && Number.isFinite(parsed.startedMs) ? parsed.startedMs : fallbackStartedMs;
     return { pid, startedMs };
@@ -45591,7 +46351,7 @@ function readCheckLockState(lockPath) {
 }
 function checkLockIsOwnedBy(lockPath, owner) {
   try {
-    const parsed = JSON.parse(readFileSync17(lockPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync18(lockPath, "utf-8"));
     return parsed.pid === owner.pid && parsed.startedMs === owner.startedMs;
   } catch {
     return false;
@@ -45601,7 +46361,7 @@ function hasRecentCheckTimestamp(file, intervalMs) {
   if (!existsSync21(file))
     return false;
   try {
-    const raw = JSON.parse(readFileSync17(file, "utf-8"));
+    const raw = JSON.parse(readFileSync18(file, "utf-8"));
     const last = typeof raw.lastCheckedMs === "number" ? raw.lastCheckedMs : 0;
     return Number.isFinite(last) && Date.now() - last < intervalMs;
   } catch {
@@ -45657,6 +46417,7 @@ async function runBackgroundUpdateCheck(ctx, options) {
   const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion);
   const latestVersion = await getLatestVersion(channel, {
     registryUrl: options.npmRegistryUrl,
+    directory: ctx.directory,
     timeoutMs: options.fetchTimeoutMs,
     signal: options.signal
   });
@@ -45797,13 +46558,13 @@ import {
   existsSync as existsSync22,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync6,
-  readFileSync as readFileSync18,
+  readFileSync as readFileSync19,
   renameSync as renameSync12,
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync13
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname15, join as join25 } from "node:path";
+import { dirname as dirname16, join as join25 } from "node:path";
 
 // src/shared/rpc-utils.ts
 import { join as join24 } from "node:path";
@@ -45953,7 +46714,7 @@ class AftRpcServer {
     }
   }
   writePortFile() {
-    const dir = dirname15(this.portFilePath);
+    const dir = dirname16(this.portFilePath);
     mkdirSync10(dir, { recursive: true, mode: 448 });
     const tmpPath = `${this.portFilePath}.tmp`;
     writeFileSync13(tmpPath, JSON.stringify({
@@ -45978,7 +46739,7 @@ class AftRpcServer {
       if (filePath === this.portFilePath)
         continue;
       try {
-        const record = parseRpcPortRecord(readFileSync18(filePath, "utf-8"));
+        const record = parseRpcPortRecord(readFileSync19(filePath, "utf-8"));
         if (record === null) {
           unlinkSync8(filePath);
           continue;
@@ -46193,7 +46954,7 @@ function formatSemanticIndexLabel(semantic) {
     backendUrl: semantic.backend_url
   });
 }
-function asRecord4(value) {
+function asRecord3(value) {
   return typeof value === "object" && value !== null ? value : {};
 }
 function readString(value, fallback = "") {
@@ -46212,7 +46973,7 @@ function readOptionalNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function readCompressionAggregate(value) {
-  const aggregate = asRecord4(value);
+  const aggregate = asRecord3(value);
   return {
     events: readNumber(aggregate.events),
     original_tokens: readNumber(aggregate.original_tokens),
@@ -46223,7 +46984,7 @@ function readCompressionAggregate(value) {
 function readCompression(value) {
   if (typeof value !== "object" || value === null)
     return;
-  const compression = asRecord4(value);
+  const compression = asRecord3(value);
   return {
     project: readCompressionAggregate(compression.project),
     session: readCompressionAggregate(compression.session)
@@ -46232,7 +46993,7 @@ function readCompression(value) {
 function readStatusBar(value) {
   if (typeof value !== "object" || value === null)
     return;
-  const bar = asRecord4(value);
+  const bar = asRecord3(value);
   const errors = readOptionalNumber(bar.errors);
   const warnings = readOptionalNumber(bar.warnings);
   const deadCode = readOptionalNumber(bar.dead_code);
@@ -46290,17 +47051,17 @@ function formatBytes(bytes) {
   return `${value.toFixed(decimals)} ${units[unitIndex]}`;
 }
 function coerceAftStatus(response) {
-  const features = asRecord4(response.features);
-  const searchIndex = asRecord4(response.search_index);
-  const semanticIndex = asRecord4(response.semantic_index);
+  const features = asRecord3(response.features);
+  const searchIndex = asRecord3(response.search_index);
+  const semanticIndex = asRecord3(response.semantic_index);
   const semanticConfig = {
-    ...asRecord4(response.semantic),
-    ...asRecord4(response.semantic_config)
+    ...asRecord3(response.semantic),
+    ...asRecord3(response.semantic_config)
   };
-  const disk = asRecord4(response.disk);
-  const symbolCache = asRecord4(response.symbol_cache);
-  const runtime = asRecord4(response.runtime);
-  const session = asRecord4(response.session);
+  const disk = asRecord3(response.disk);
+  const symbolCache = asRecord3(response.symbol_cache);
+  const runtime = asRecord3(response.runtime);
+  const session = asRecord3(response.session);
   return {
     version: readString(response.version, "unknown"),
     project_root: readNullableString(response.project_root),
@@ -46841,6 +47602,16 @@ async function initializePluginForDirectory(input) {
     storageDir: configOverrides.storage_dir,
     isProjectEnabled
   };
+  const liveConfigReload = startOpenCodeLiveConfigReload({
+    directory: registrationRoot,
+    initialSources: bootstrap.sources ?? [],
+    initialSourceTexts: bootstrap.sourceTexts,
+    getConfig: () => ctx.config,
+    setConfig: (config) => {
+      ctx.config = config;
+    },
+    notify: (message) => deliverConfigMigrationWarnings(registrationRoot, [message])
+  });
   const statusSubscribedBridges = new WeakSet;
   const statusUnsubscribes = new Set;
   const subscribeBridgeStatus = (bridge) => {
@@ -46878,6 +47649,7 @@ async function initializePluginForDirectory(input) {
   let clearInspectTier2Idle = () => {};
   const shutdownCleanup = registerShutdownCleanup(async (reason) => {
     autoUpdateAbort.abort();
+    liveConfigReload.stop();
     clearInspectTier2Idle();
     for (const unsubscribe of statusUnsubscribes) {
       try {
@@ -47036,7 +47808,7 @@ Install: ${getManualInstallHint()}`);
   }
   const inspectTier2Idle = createInspectTier2IdleScheduler({
     isEnabled: () => registeredTools.has("aft_inspect"),
-    idleMinutes: () => aftConfig.inspect?.tier2_idle_minutes,
+    idleMinutes: () => ctx.config.inspect?.tier2_idle_minutes,
     warn: warn2,
     run: async (sessionID) => {
       const sessionDir = await getSessionDirectory(input.client, sessionID, input.directory) ?? input.directory;
@@ -47094,11 +47866,17 @@ Install: ${getManualInstallHint()}`);
           storageDir: configOverrides.storage_dir,
           pluginVersion: PLUGIN_VERSION,
           serverUrl: input.serverUrl?.toString(),
-          delivery: aftConfig.configure_warnings_delivery ?? "toast"
+          delivery: ctx.config.configure_warnings_delivery ?? "toast"
         });
       }
       await flushConfigureWarningsOnIdle(sessionID);
     },
+    "chat.params": async (params) => {
+      rememberReadModel(input.client, params.sessionID, {
+        providerID: params.model.providerID,
+        modelID: params.model.id
+      });
+    },
     "chat.message": async (messageInput, messageOutput) => {
       const sid = messageInput.sessionID ?? messageInput.sessionId ?? messageInput.id;
       warmSessionDirectory(input.client, sid, input.directory);