@cydm/pie 1.0.41 → 1.0.42

package/dist/cli.js

@@ -19,7 +19,7 @@ import {
   getThemesDir,
   migrateConfigFromAgentDir,
   truncateHeadTail
-} from "./chunks/chunk-4WGEYDPO.js";
+} from "./chunks/chunk-VYAW6RAX.js";
 import {
   AGENTS_CONTEXT_FILE_NAME,
   AgentSessionController,
@@ -69,8 +69,8 @@ import {
   setExtensionEnabledInSettings,
   shouldPreserveExecutionStateForUserText,
   supersedeExecutionState
-} from "./chunks/chunk-OBCFKF6H.js";
-import "./chunks/chunk-E3ELBCCX.js";
+} from "./chunks/chunk-2GVFMYIV.js";
+import "./chunks/chunk-JVLAKTAS.js";
 import {
   Deref,
   EMPTY_ASSISTANT_CONTENT_ERROR,
@@ -106,7 +106,7 @@ import {
   setLogger,
   sortToolModelCandidatesByCapability,
   type_exports
-} from "./chunks/chunk-YCPKJCUB.js";
+} from "./chunks/chunk-NGQ3PUOC.js";
 import {
   resolveCliProjectRoot
 } from "./chunks/chunk-NTYHFBUA.js";
@@ -114,7 +114,7 @@ import {
   __commonJS,
   __require,
   __toESM
-} from "./chunks/chunk-TG2EQLX2.js";
+} from "./chunks/chunk-LZQXQOPJ.js";
 
 // ../../node_modules/color-name/index.js
 var require_color_name = __commonJS({
@@ -986,15 +986,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path31 = [graph[toModel].parent, toModel];
+      const path33 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path31.unshift(graph[cur].parent);
+        path33.unshift(graph[cur].parent);
         fn = link(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path31;
+      fn.conversion = path33;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -1234,7 +1234,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/chalk/node_modules/supports-color/index.js"(exports, module) {
     "use strict";
-    var os7 = __require("os");
+    var os9 = __require("os");
     var tty = __require("tty");
     var hasFlag2 = require_has_flag();
     var { env } = process;
@@ -1282,7 +1282,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os7.release().split(".");
+        const osRelease = os9.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -1917,7 +1917,7 @@ var require_core = __commonJS({
       return match && match.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join19(regexps, separator = "|") {
+    function join21(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex) => {
         numCaptures += 1;
@@ -2221,7 +2221,7 @@ var require_core = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join19(terminators), true);
+          this.matcherRe = langRe(join21(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -43958,8 +43958,8 @@ var require_dist = __commonJS({
 });
 
 // src/cli.ts
-import * as fs27 from "fs";
-import * as path30 from "path";
+import * as fs28 from "fs";
+import * as path32 from "path";
 
 // src/cli-args.ts
 var FLAGS_WITH_VALUES = /* @__PURE__ */ new Set(["--session-id", "--extension-path", "--developer-instructions", "--developer-instructions-file"]);
@@ -44374,17 +44374,211 @@ function installInteractiveConsoleInterception(runtimeLogger) {
 // src/doctor.ts
 import { spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 import * as os from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import { delimiter } from "node:path";
 
 // src/core/auth-storage.ts
-var AuthStorage = class {
+import * as fs2 from "fs";
+import * as path2 from "path";
+var AUTH_LOCK_WRITE_GRACE_MS = 1e3;
+var DEFAULT_AUTH_LOCK_WAIT_MS = 2e3;
+var OAUTH_EXPIRY_SKEW_MS = 3e4;
+function syncSleepMs(ms) {
+  if (ms <= 0) return;
+  const cell = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(cell, 0, 0, ms);
+}
+function processIsAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+var InMemoryAuthStorageBackend = class {
+  snapshot = { oauth: {} };
+  read() {
+    return { oauth: { ...this.snapshot.oauth } };
+  }
+  write(snapshot) {
+    this.snapshot = { oauth: { ...snapshot.oauth } };
+  }
+};
+var AUTH_FILE_VERSION = 1;
+var FileAuthStorageBackend = class {
+  constructor(authPath = path2.join(getConfigDir(), "auth.json"), lockWaitMs = DEFAULT_AUTH_LOCK_WAIT_MS) {
+    this.authPath = authPath;
+    this.lockWaitMs = lockWaitMs;
+  }
+  authPath;
+  lockWaitMs;
+  errors = [];
+  read() {
+    try {
+      if (!fs2.existsSync(this.authPath)) return { oauth: {} };
+      const raw = JSON.parse(fs2.readFileSync(this.authPath, "utf8"));
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { oauth: {} };
+      const oauth = raw.oauth;
+      if (!oauth || typeof oauth !== "object" || Array.isArray(oauth)) return { oauth: {} };
+      return { oauth: { ...oauth } };
+    } catch (error) {
+      this.errors.push(error instanceof Error ? error : new Error(String(error)));
+      return { oauth: {} };
+    }
+  }
+  /** A lock whose owner is gone (or that never got populated) may be reclaimed. */
+  lockIsStale(lockPath) {
+    const stat2 = fs2.lstatSync(lockPath);
+    if (stat2.isSymbolicLink() || !stat2.isFile()) return true;
+    let owner;
+    try {
+      owner = JSON.parse(fs2.readFileSync(lockPath, "utf8"));
+    } catch {
+    }
+    const age = Date.now() - stat2.mtimeMs;
+    const validOwner = owner?.version === 1 && Number.isSafeInteger(owner.pid) && typeof owner.token === "string" && typeof owner.createdAt === "number";
+    if (validOwner && processIsAlive(Number(owner.pid))) return false;
+    return validOwner || age > AUTH_LOCK_WRITE_GRACE_MS;
+  }
+  /** Atomically claim a stale lock via hard-link identity comparison before removing it. */
+  reclaimStaleLock(lockPath) {
+    if (!this.lockIsStale(lockPath)) return false;
+    const claimPath = `${lockPath}.reclaim-${process.pid}-${Math.random().toString(36).slice(2)}`;
+    try {
+      fs2.linkSync(lockPath, claimPath);
+      const claimed = fs2.lstatSync(claimPath);
+      const current = fs2.lstatSync(lockPath);
+      if (claimed.isSymbolicLink() || !claimed.isFile() || current.isSymbolicLink() || !current.isFile()) return false;
+      if (claimed.dev !== current.dev || claimed.ino !== current.ino) return false;
+      fs2.unlinkSync(lockPath);
+      return true;
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "EEXIST") return false;
+      throw error;
+    } finally {
+      try {
+        fs2.unlinkSync(claimPath);
+      } catch {
+      }
+    }
+  }
+  /** Acquire the fixed-path cross-process lock; the release fn is token-checked. */
+  acquireLock(directory, lockPath) {
+    fs2.mkdirSync(directory, { recursive: true, mode: 448 });
+    const deadline = Date.now() + this.lockWaitMs;
+    while (true) {
+      const token = `${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+      try {
+        const fd = fs2.openSync(lockPath, "wx", 384);
+        try {
+          fs2.writeFileSync(fd, `${JSON.stringify({ version: 1, pid: process.pid, token, createdAt: Date.now() })}
+`);
+        } finally {
+          fs2.closeSync(fd);
+        }
+        return () => {
+          try {
+            const owner = JSON.parse(fs2.readFileSync(lockPath, "utf8"));
+            if (owner?.token === token) fs2.unlinkSync(lockPath);
+          } catch {
+          }
+        };
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        try {
+          if (this.reclaimStaleLock(lockPath)) continue;
+        } catch (reclaimError) {
+          if (reclaimError.code === "ENOENT") continue;
+          throw reclaimError;
+        }
+        if (Date.now() >= deadline) throw new Error(`timed out waiting for auth storage lock: ${lockPath}`);
+        syncSleepMs(25);
+      }
+    }
+  }
+  /**
+   * Merge-on-write under a fixed-path cross-process lock: re-read the file,
+   * apply explicit removals (logout), merge our snapshot's oauth entries
+   * over whatever is on disk (preserving unrelated edits), then write back
+   * atomically with 0600 permissions.
+   */
+  write(snapshot) {
+    const directory = path2.dirname(this.authPath);
+    const lockPath = `${this.authPath}.lock`;
+    let release;
+    try {
+      release = this.acquireLock(directory, lockPath);
+      try {
+        const onDisk = this.read();
+        const mergedOauth = { ...onDisk.oauth };
+        for (const removed of snapshot.removedOauth ?? []) {
+          delete mergedOauth[removed];
+        }
+        Object.assign(mergedOauth, snapshot.oauth);
+        const merged = {
+          version: AUTH_FILE_VERSION,
+          oauth: mergedOauth
+        };
+        const temporary = `${this.authPath}.${process.pid}.tmp`;
+        try {
+          fs2.writeFileSync(temporary, `${JSON.stringify(merged, null, 2)}
+`, { flag: "wx", mode: 384 });
+          fs2.renameSync(temporary, this.authPath);
+        } finally {
+          if (fs2.existsSync(temporary)) fs2.unlinkSync(temporary);
+        }
+      } finally {
+        release();
+      }
+    } catch (error) {
+      this.errors.push(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  drainErrors() {
+    return this.errors.splice(0);
+  }
+};
+var AuthStorage = class _AuthStorage {
   providerApiKeys = /* @__PURE__ */ new Map();
   runtimeApiKeys = /* @__PURE__ */ new Map();
   providerEnvVars = /* @__PURE__ */ new Map();
   legacyApiKey;
+  oauthCredentials = /* @__PURE__ */ new Map();
+  removedOauthProviders = /* @__PURE__ */ new Set();
+  backend;
+  constructor(backend) {
+    this.backend = backend;
+    if (backend) {
+      for (const [provider, credentials] of Object.entries(backend.read().oauth)) {
+        this.oauthCredentials.set(provider, credentials);
+      }
+    }
+  }
+  /** Runtime-only storage (no persistence). */
+  static create() {
+    return new _AuthStorage();
+  }
+  /** Storage bound to a persistence backend (OAuth credentials survive restarts). */
+  static fromStorage(backend) {
+    return new _AuthStorage(backend);
+  }
+  /** In-memory backend, for tests and embedders that manage their own persistence. */
+  static inMemory() {
+    return new _AuthStorage(new InMemoryAuthStorageBackend());
+  }
+  /** Drain buffered backend I/O errors (file backend only). */
+  drainErrors() {
+    const backend = this.backend;
+    if (backend && typeof backend.drainErrors === "function") {
+      return backend.drainErrors();
+    }
+    return [];
+  }
   setLegacyApiKey(apiKey) {
     this.legacyApiKey = apiKey;
   }
@@ -44412,20 +44606,104 @@ var AuthStorage = class {
   getProviderEnvVar(provider) {
     return this.providerEnvVars.get(provider);
   }
+  setOAuthCredentials(provider, credentials) {
+    if (!credentials) {
+      this.oauthCredentials.delete(provider);
+      this.removedOauthProviders.add(provider);
+      this.runtimeApiKeys.delete(provider);
+    } else {
+      this.oauthCredentials.set(provider, credentials);
+      this.removedOauthProviders.delete(provider);
+    }
+    this.persistOAuth();
+  }
+  getOAuthCredentials(provider) {
+    return this.oauthCredentials.get(provider);
+  }
+  /** Providers with persisted OAuth credentials (for restore/refresh passes). */
+  getOAuthProviderNames() {
+    return [...this.oauthCredentials.keys()];
+  }
+  persistOAuth() {
+    if (!this.backend) return;
+    this.backend.write({
+      oauth: Object.fromEntries(this.oauthCredentials),
+      removedOauth: [...this.removedOauthProviders]
+    });
+  }
   getApiKey(provider, explicitEnvVar) {
     const envVar = explicitEnvVar || this.getProviderEnvVar(provider);
     const envApiKey = envVar && typeof process !== "undefined" ? process.env?.[envVar] : void 0;
-    return this.runtimeApiKeys.get(provider) || this.providerApiKeys.get(provider) || envApiKey || this.legacyApiKey;
+    return this.runtimeApiKeys.get(provider) || this.providerApiKeys.get(provider) || envApiKey || this.usableOAuthAccessToken(provider) || this.legacyApiKey;
+  }
+  /** Persisted OAuth access token, when it exists and has not expired. */
+  usableOAuthAccessToken(provider) {
+    const credentials = this.oauthCredentials.get(provider);
+    if (!credentials?.access) return void 0;
+    if (credentials.expires !== void 0 && credentials.expires <= Date.now() + OAUTH_EXPIRY_SKEW_MS) {
+      return void 0;
+    }
+    return credentials.access;
   }
 };
 
 // src/core/model-registry.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import { createHash, createHmac, randomBytes } from "node:crypto";
+var MODEL_OVERRIDE_KEYS = [
+  "name",
+  "reasoning",
+  "input",
+  "cost",
+  "contextWindow",
+  "maxTokens",
+  "headers",
+  "compat",
+  "cacheCapability",
+  "webSearch",
+  "fileCapabilities",
+  "displayName"
+];
+function validateExtensionProviderConfig(provider, config) {
+  if (!provider || provider !== provider.trim() || /\s/.test(provider)) throw new Error(`registerProvider: invalid provider id "${provider}"`);
+  if (!config || typeof config !== "object") throw new Error("registerProvider: config must be an object");
+  if (typeof config.baseUrl !== "string" || !config.baseUrl) throw new Error(`registerProvider("${provider}"): baseUrl is required`);
+  try {
+    new URL(config.baseUrl);
+  } catch {
+    throw new Error(`registerProvider("${provider}"): baseUrl must be an absolute URL`);
+  }
+  assertHeadersShape(config.headers, `registerProvider("${provider}")`);
+  for (const model of config.models ?? []) {
+    if (!model || typeof model.id !== "string" || !model.id.trim() || /\s/.test(model.id)) throw new Error(`registerProvider("${provider}"): invalid model id`);
+    assertHeadersShape(model.headers, `registerProvider("${provider}") model "${model.id}"`);
+    validateCompat(model.compat, `registerProvider("${provider}") model "${model.id}" compat`);
+    validateCacheCapability(model.cacheCapability, `registerProvider("${provider}") model "${model.id}" cacheCapability`);
+    validateWebSearchCapability(model.webSearch, `registerProvider("${provider}") model "${model.id}" webSearch`);
+    validateFileCapabilities(model.fileCapabilities, `registerProvider("${provider}") model "${model.id}" fileCapabilities`);
+  }
+}
 var REMOTE_CATALOG_CACHE_VERSION = 4;
 var SUPPORTED_REMOTE_APIS = /* @__PURE__ */ new Set(["openai-completions", "anthropic-messages"]);
 var MAX_REMOTE_CATALOG_BYTES = 2 * 1024 * 1024;
+var OAUTH_RESTORE_LEEWAY_MS = 6e4;
+var OAUTH_REFRESH_TIMEOUT_MS = 3e4;
+function withTimeout(promise, ms, timeoutMessage) {
+  return new Promise((resolve7, reject) => {
+    const timer = setTimeout(() => reject(new Error(timeoutMessage)), ms);
+    Promise.resolve(promise).then(
+      (value) => {
+        clearTimeout(timer);
+        resolve7(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
 var REMOTE_REFRESH_LOCK_WAIT_MS = 6e4;
 var REMOTE_REFRESH_LOCK_WRITE_GRACE_MS = 1e3;
 var remoteRefreshTails = /* @__PURE__ */ new Map();
@@ -44449,40 +44727,40 @@ function remoteIdentityDigest(remote) {
   return createHash("sha256").update(JSON.stringify({ version: REMOTE_CATALOG_CACHE_VERSION, ...canonicalRemote(remote) })).digest("hex");
 }
 function remoteCacheDirectory(modelsPath) {
-  return path2.join(path2.dirname(modelsPath), "cache", "remote-catalogs");
+  return path3.join(path3.dirname(modelsPath), "cache", "remote-catalogs");
 }
 function safeRemoteCacheDirectory(modelsPath, create) {
-  const configDirectory = path2.dirname(modelsPath);
-  if (!fs2.existsSync(configDirectory)) {
+  const configDirectory = path3.dirname(modelsPath);
+  if (!fs3.existsSync(configDirectory)) {
     if (!create) return void 0;
-    fs2.mkdirSync(configDirectory, { recursive: true, mode: 448 });
+    fs3.mkdirSync(configDirectory, { recursive: true, mode: 448 });
   }
-  const configRoot = fs2.realpathSync(configDirectory);
-  const cacheRoot = path2.join(configDirectory, "cache");
+  const configRoot = fs3.realpathSync(configDirectory);
+  const cacheRoot = path3.join(configDirectory, "cache");
   const directory = remoteCacheDirectory(modelsPath);
   for (const candidate of [cacheRoot, directory]) {
-    if (!fs2.existsSync(candidate)) {
+    if (!fs3.existsSync(candidate)) {
       if (!create) return void 0;
-      fs2.mkdirSync(candidate, { mode: 448 });
+      fs3.mkdirSync(candidate, { mode: 448 });
     }
-    const stat2 = fs2.lstatSync(candidate);
+    const stat2 = fs3.lstatSync(candidate);
     if (stat2.isSymbolicLink() || !stat2.isDirectory()) throw new Error(`remote catalog cache path must be a real directory: ${candidate}`);
-    const canonical = fs2.realpathSync(candidate);
-    const relative2 = path2.relative(configRoot, canonical);
-    if (relative2 === ".." || relative2.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative2)) {
+    const canonical = fs3.realpathSync(candidate);
+    const relative3 = path3.relative(configRoot, canonical);
+    if (relative3 === ".." || relative3.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative3)) {
       throw new Error(`remote catalog cache path escapes the config directory: ${candidate}`);
     }
     try {
-      fs2.chmodSync(candidate, 448);
+      fs3.chmodSync(candidate, 448);
     } catch {
     }
   }
   return directory;
 }
 function remoteRefreshLockPath(modelsPath) {
-  return path2.join(remoteCacheDirectory(modelsPath), ".refresh.lock");
+  return path3.join(remoteCacheDirectory(modelsPath), ".refresh.lock");
 }
-function processIsAlive(pid) {
+function processIsAlive2(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return false;
   try {
     process.kill(pid, 0);
@@ -44492,40 +44770,40 @@ function processIsAlive(pid) {
   }
 }
 function remoteRefreshLockIsStale(lockPath) {
-  const stat2 = fs2.lstatSync(lockPath);
+  const stat2 = fs3.lstatSync(lockPath);
   if (stat2.isSymbolicLink() || !stat2.isFile()) throw new Error(`remote catalog refresh lock must be a regular file: ${lockPath}`);
   let owner;
   try {
-    owner = JSON.parse(fs2.readFileSync(lockPath, "utf8"));
+    owner = JSON.parse(fs3.readFileSync(lockPath, "utf8"));
   } catch {
   }
   const age = Date.now() - stat2.mtimeMs;
   const validOwner = owner?.version === 1 && Number.isSafeInteger(owner.pid) && typeof owner.token === "string" && typeof owner.createdAt === "number";
-  if (validOwner && processIsAlive(Number(owner.pid))) return false;
+  if (validOwner && processIsAlive2(Number(owner.pid))) return false;
   return validOwner || age > REMOTE_REFRESH_LOCK_WRITE_GRACE_MS;
 }
 function sameFileIdentity(left, right, leftPath, rightPath) {
   if (left.dev !== right.dev || left.ino !== right.ino) return false;
   if (left.ino !== 0) return true;
-  return left.size === right.size && fs2.readFileSync(leftPath).equals(fs2.readFileSync(rightPath));
+  return left.size === right.size && fs3.readFileSync(leftPath).equals(fs3.readFileSync(rightPath));
 }
 function reclaimStaleRemoteRefreshLock(lockPath) {
   if (!remoteRefreshLockIsStale(lockPath)) return false;
   const claimPath = `${lockPath}.reclaim-${process.pid}-${randomBytes(8).toString("hex")}`;
   try {
-    fs2.linkSync(lockPath, claimPath);
-    const claimed = fs2.lstatSync(claimPath);
-    const current = fs2.lstatSync(lockPath);
+    fs3.linkSync(lockPath, claimPath);
+    const claimed = fs3.lstatSync(claimPath);
+    const current = fs3.lstatSync(lockPath);
     if (claimed.isSymbolicLink() || !claimed.isFile() || current.isSymbolicLink() || !current.isFile() || !sameFileIdentity(claimed, current, claimPath, lockPath)) return false;
     if (!remoteRefreshLockIsStale(claimPath)) return false;
-    fs2.unlinkSync(lockPath);
+    fs3.unlinkSync(lockPath);
     return true;
   } catch (error) {
     if (["ENOENT", "EEXIST"].includes(error.code ?? "")) return false;
     throw error;
   } finally {
     try {
-      fs2.unlinkSync(claimPath);
+      fs3.unlinkSync(claimPath);
     } catch {
     }
   }
@@ -44537,19 +44815,19 @@ async function acquireRemoteRefreshLock(modelsPath) {
   while (true) {
     const token = randomBytes(16).toString("hex");
     try {
-      const fd = fs2.openSync(lockPath, "wx", 384);
+      const fd = fs3.openSync(lockPath, "wx", 384);
       try {
-        fs2.writeFileSync(fd, `${JSON.stringify({ version: 1, pid: process.pid, token, createdAt: Date.now() })}
+        fs3.writeFileSync(fd, `${JSON.stringify({ version: 1, pid: process.pid, token, createdAt: Date.now() })}
 `);
       } finally {
-        fs2.closeSync(fd);
+        fs3.closeSync(fd);
       }
       return () => {
         try {
-          const stat2 = fs2.lstatSync(lockPath);
+          const stat2 = fs3.lstatSync(lockPath);
           if (stat2.isSymbolicLink() || !stat2.isFile()) return;
-          const current = JSON.parse(fs2.readFileSync(lockPath, "utf8"));
-          if (current.token === token) fs2.unlinkSync(lockPath);
+          const current = JSON.parse(fs3.readFileSync(lockPath, "utf8"));
+          if (current.token === token) fs3.unlinkSync(lockPath);
         } catch {
         }
       };
@@ -44562,29 +44840,29 @@ async function acquireRemoteRefreshLock(modelsPath) {
         throw lockError;
       }
       if (Date.now() >= deadline) throw new Error(`timed out waiting for remote catalog refresh lock: ${lockPath}`);
-      await new Promise((resolve6) => setTimeout(resolve6, 25));
+      await new Promise((resolve7) => setTimeout(resolve7, 25));
     }
   }
 }
 function readSafeRemoteCacheFile(directory, filepath) {
-  const stat2 = fs2.lstatSync(filepath);
+  const stat2 = fs3.lstatSync(filepath);
   if (stat2.isSymbolicLink() || !stat2.isFile()) throw new Error(`remote catalog cache entry must be a regular file: ${filepath}`);
-  const canonicalDirectory = fs2.realpathSync(directory);
-  const canonicalFile = fs2.realpathSync(filepath);
-  const relative2 = path2.relative(canonicalDirectory, canonicalFile);
-  if (!relative2 || relative2 === ".." || relative2.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative2)) {
+  const canonicalDirectory = fs3.realpathSync(directory);
+  const canonicalFile = fs3.realpathSync(filepath);
+  const relative3 = path3.relative(canonicalDirectory, canonicalFile);
+  if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative3)) {
     throw new Error(`remote catalog cache entry escapes its cache directory: ${filepath}`);
   }
-  return fs2.readFileSync(filepath);
+  return fs3.readFileSync(filepath);
 }
 function credentialNamespaceKey(modelsPath, create) {
   const directory = safeRemoteCacheDirectory(modelsPath, create);
   if (!directory) return void 0;
-  const keyPath = path2.join(directory, ".credential-namespace-key");
-  if (!fs2.existsSync(keyPath) && !create) return void 0;
-  if (create && !fs2.existsSync(keyPath)) {
+  const keyPath = path3.join(directory, ".credential-namespace-key");
+  if (!fs3.existsSync(keyPath) && !create) return void 0;
+  if (create && !fs3.existsSync(keyPath)) {
     try {
-      fs2.writeFileSync(keyPath, randomBytes(32), { flag: "wx", mode: 384 });
+      fs3.writeFileSync(keyPath, randomBytes(32), { flag: "wx", mode: 384 });
     } catch (error) {
       if (!isPlainRecord(error) || error.code !== "EEXIST") throw error;
     }
@@ -44592,7 +44870,7 @@ function credentialNamespaceKey(modelsPath, create) {
   const key = readSafeRemoteCacheFile(directory, keyPath);
   if (key.byteLength !== 32) throw new Error("remote catalog credential namespace key is invalid");
   try {
-    fs2.chmodSync(keyPath, 384);
+    fs3.chmodSync(keyPath, 384);
   } catch {
   }
   return key;
@@ -44603,28 +44881,28 @@ function credentialFingerprint(modelsPath, remote, credential, create = false) {
   return createHmac("sha256", key).update(remoteIdentityDigest(remote)).update("\0").update(credential).digest("hex");
 }
 function remoteCachePath(modelsPath, remote, fingerprint) {
-  return path2.join(remoteCacheDirectory(modelsPath), `${remoteIdentityDigest(remote)}-${fingerprint}.json`);
+  return path3.join(remoteCacheDirectory(modelsPath), `${remoteIdentityDigest(remote)}-${fingerprint}.json`);
 }
 function pruneLegacyRemoteCatalogCaches(modelsPath) {
   const directory = safeRemoteCacheDirectory(modelsPath, false);
   if (!directory) return;
-  for (const name of fs2.readdirSync(directory)) {
+  for (const name of fs3.readdirSync(directory)) {
     if (!name.endsWith(".json")) continue;
-    const filepath = path2.join(directory, name);
+    const filepath = path3.join(directory, name);
     try {
       const value = JSON.parse(readSafeRemoteCacheFile(directory, filepath).toString("utf8"));
       if (value.version === REMOTE_CATALOG_CACHE_VERSION) continue;
     } catch {
       let stat2;
       try {
-        stat2 = fs2.lstatSync(filepath);
+        stat2 = fs3.lstatSync(filepath);
       } catch {
         continue;
       }
       if (stat2.isSymbolicLink() || !stat2.isFile()) continue;
     }
     try {
-      fs2.unlinkSync(filepath);
+      fs3.unlinkSync(filepath);
     } catch {
     }
   }
@@ -44633,7 +44911,7 @@ function scrubActiveSecretsFromRemoteCaches(modelsPath, activeSecrets) {
   if (activeSecrets.length === 0) return;
   const directory = safeRemoteCacheDirectory(modelsPath, false);
   if (!directory) return;
-  const handle = fs2.opendirSync(directory);
+  const handle = fs3.opendirSync(directory);
   try {
     let scanned = 0;
     while (true) {
@@ -44643,14 +44921,14 @@ function scrubActiveSecretsFromRemoteCaches(modelsPath, activeSecrets) {
       const isCache = entry.name.endsWith(".json");
       const isOrphanedTemporary = /^\..+\.json\.\d+\.[0-9a-f]+\.tmp$/.test(entry.name);
       if (!entry.isFile() || !isCache && !isOrphanedTemporary) continue;
-      const filepath = path2.join(directory, entry.name);
+      const filepath = path3.join(directory, entry.name);
       try {
         const raw = readSafeRemoteCacheFile(directory, filepath).toString("utf8");
         assertNoSecretSubstrings(raw, activeSecrets, "remote catalog cache");
       } catch {
         try {
-          const stat2 = fs2.lstatSync(filepath);
-          if (!stat2.isSymbolicLink() && stat2.isFile()) fs2.unlinkSync(filepath);
+          const stat2 = fs3.lstatSync(filepath);
+          if (!stat2.isSymbolicLink() && stat2.isFile()) fs3.unlinkSync(filepath);
         } catch {
         }
       }
@@ -44721,7 +44999,7 @@ function readRemoteCache(modelsPath, remote, fingerprint, activeSecrets) {
     const directory = safeRemoteCacheDirectory(modelsPath, false);
     if (!directory) return void 0;
     const tombstone = remoteCacheTombstonePath(modelsPath, remote, fingerprint);
-    if (fs2.existsSync(tombstone)) return void 0;
+    if (fs3.existsSync(tombstone)) return void 0;
     const value = JSON.parse(readSafeRemoteCacheFile(directory, remoteCachePath(modelsPath, remote, fingerprint)).toString("utf8"));
     if (value.version !== REMOTE_CATALOG_CACHE_VERSION || !sameRemoteIdentity(value.identity, remote) || value.credentialFingerprint !== fingerprint || typeof value.payloadSha256 !== "string" || value.payloadSha256 !== payloadDigest(value.payload)) return void 0;
     assertNoSecretSubstrings({ etag: value.etag, payload: value.payload }, activeSecrets, "remote catalog cache");
@@ -44741,23 +45019,23 @@ function removeRemoteCache(modelsPath, remote, fingerprint) {
     const directory = safeRemoteCacheDirectory(modelsPath, false);
     if (!directory) return;
     const filepath = remoteCachePath(modelsPath, remote, fingerprint);
-    if (fs2.existsSync(filepath)) {
-      const stat2 = fs2.lstatSync(filepath);
+    if (fs3.existsSync(filepath)) {
+      const stat2 = fs3.lstatSync(filepath);
       if (stat2.isSymbolicLink() || !stat2.isFile()) throw new Error(`remote catalog cache entry is not a regular file: ${filepath}`);
-      fs2.unlinkSync(filepath);
+      fs3.unlinkSync(filepath);
     }
     const tombstone = remoteCacheTombstonePath(modelsPath, remote, fingerprint);
-    if (fs2.existsSync(tombstone)) fs2.unlinkSync(tombstone);
+    if (fs3.existsSync(tombstone)) fs3.unlinkSync(tombstone);
     return;
   } catch (error) {
     const directory = safeRemoteCacheDirectory(modelsPath, true);
     if (!directory) throw error;
     const tombstone = remoteCacheTombstonePath(modelsPath, remote, fingerprint);
     try {
-      fs2.writeFileSync(tombstone, `${JSON.stringify({ version: 1, revoked: true })}
+      fs3.writeFileSync(tombstone, `${JSON.stringify({ version: 1, revoked: true })}
 `, { flag: "wx", mode: 384 });
     } catch (tombstoneError) {
-      if (!fs2.existsSync(tombstone)) throw tombstoneError;
+      if (!fs3.existsSync(tombstone)) throw tombstoneError;
     }
   }
 }
@@ -44819,7 +45097,7 @@ function validatedRemoteCatalogs(value) {
 }
 function validateModelsDocumentShape(value) {
   if (!isPlainRecord(value)) throw new Error("models.json must be an object");
-  assertOnlyKeys(value, ["$schema", "profiles", "remoteCatalogs", "defaults"], "models.json");
+  assertOnlyKeys(value, ["$schema", "profiles", "remoteCatalogs", "defaults", "modelOverrides"], "models.json");
   if (value.$schema !== void 0 && (typeof value.$schema !== "string" || !value.$schema)) throw new Error("models.json $schema must be a non-empty string");
   const hasProfiles = Object.prototype.hasOwnProperty.call(value, "profiles");
   const hasRemoteCatalogs = Object.prototype.hasOwnProperty.call(value, "remoteCatalogs");
@@ -44832,6 +45110,7 @@ function validateModelsDocumentShape(value) {
       validateProfileConfig(profileId, profile);
     }
   }
+  validateModelOverrides(value.modelOverrides);
   if (value.defaults !== void 0) {
     if (!isPlainRecord(value.defaults)) throw new Error("models.json defaults must be an object");
     assertOnlyKeys(value.defaults, ["provider", "modelId", "modelClasses", "toolModels"], "models.json defaults");
@@ -44916,6 +45195,8 @@ function validateCompat(value, label) {
     "requiresAssistantAfterToolResult",
     "requiresThinkingAsText",
     "supportsStrictMode",
+    "streamRequiresDone",
+    "streamRequiresFinishReason",
     "cacheCapability"
   ], label);
   if (value.forcedReasoningEffort !== void 0 && value.forcedReasoningEffort !== "none") {
@@ -44929,7 +45210,9 @@ function validateCompat(value, label) {
     "requiresToolResultName",
     "requiresAssistantAfterToolResult",
     "requiresThinkingAsText",
-    "supportsStrictMode"
+    "supportsStrictMode",
+    "streamRequiresDone",
+    "streamRequiresFinishReason"
   ]) assertOptionalBoolean(value[field], `${label}.${field}`);
   if (value.maxTokensField !== void 0 && value.maxTokensField !== "max_completion_tokens" && value.maxTokensField !== "max_tokens") {
     throw new Error(`${label}.maxTokensField is invalid`);
@@ -45108,6 +45391,46 @@ async function readResponseTextBounded(response, maxBytes) {
     reader.releaseLock();
   }
 }
+function deepMergePlainRecords(base, patch) {
+  const result = isPlainRecord(base) ? { ...base } : {};
+  if (!isPlainRecord(patch)) return result;
+  for (const [key, value] of Object.entries(patch)) {
+    const current = result[key];
+    result[key] = isPlainRecord(current) && isPlainRecord(value) ? deepMergePlainRecords(current, value) : value;
+  }
+  return result;
+}
+function validateModelOverrides(value) {
+  if (value === void 0) return;
+  if (!isPlainRecord(value)) throw new Error("models.json modelOverrides must be an object");
+  for (const [key, override] of Object.entries(value)) {
+    if (!/^[^\s/]+\/[^\s/]+$/.test(key)) throw new Error(`models.json modelOverrides key must be "provider/modelId": ${key}`);
+    if (!isPlainRecord(override)) throw new Error(`models.json modelOverrides["${key}"] must be an object`);
+    assertOnlyKeys(override, [...MODEL_OVERRIDE_KEYS], `models.json modelOverrides["${key}"]`);
+    if (override.name !== void 0 && (typeof override.name !== "string" || !override.name.trim())) throw new Error(`models.json modelOverrides["${key}"].name must be a non-empty string`);
+    if (override.displayName !== void 0 && (typeof override.displayName !== "string" || !override.displayName.trim())) throw new Error(`models.json modelOverrides["${key}"].displayName must be a non-empty string`);
+    if (override.reasoning !== void 0 && typeof override.reasoning !== "boolean") throw new Error(`models.json modelOverrides["${key}"].reasoning must be a boolean`);
+    if (override.input !== void 0 && (!Array.isArray(override.input) || override.input.length === 0 || override.input.some((kind) => !["text", "image", "audio", "video"].includes(String(kind))))) throw new Error(`models.json modelOverrides["${key}"].input is invalid`);
+    if (override.contextWindow !== void 0 && (!Number.isInteger(override.contextWindow) || Number(override.contextWindow) < 1)) throw new Error(`models.json modelOverrides["${key}"].contextWindow is invalid`);
+    if (override.maxTokens !== void 0 && (!Number.isInteger(override.maxTokens) || Number(override.maxTokens) < 1)) throw new Error(`models.json modelOverrides["${key}"].maxTokens is invalid`);
+    if (override.cost !== void 0) {
+      if (!isPlainRecord(override.cost)) throw new Error(`models.json modelOverrides["${key}"].cost must be an object`);
+      for (const field of ["input", "output", "cacheRead", "cacheWrite"]) {
+        if (override.cost[field] !== void 0 && (typeof override.cost[field] !== "number" || Number.isNaN(override.cost[field]))) throw new Error(`models.json modelOverrides["${key}"].cost.${field} must be a number`);
+      }
+    }
+    if (override.headers !== void 0) {
+      if (!isPlainRecord(override.headers)) throw new Error(`models.json modelOverrides["${key}"].headers must be an object`);
+      for (const [headerName, headerValue] of Object.entries(override.headers)) {
+        if (typeof headerValue !== "string") throw new Error(`models.json modelOverrides["${key}"].headers.${headerName} must be a string`);
+      }
+    }
+    validateCompat(override.compat, `models.json modelOverrides["${key}"].compat`);
+    validateCacheCapability(override.cacheCapability, `models.json modelOverrides["${key}"].cacheCapability`);
+    validateWebSearchCapability(override.webSearch, `models.json modelOverrides["${key}"].webSearch`);
+    validateFileCapabilities(override.fileCapabilities, `models.json modelOverrides["${key}"].fileCapabilities`);
+  }
+}
 function validateProfileConfig(profileId, profileConfig) {
   if (!isPlainRecord(profileConfig)) throw new Error(`Profile "${profileId}" must be an object.`);
   assertOnlyKeys(profileConfig, [
@@ -45202,12 +45525,14 @@ var ModelRegistry = class {
   modelsPath;
   configDefaults;
   modelOrder = [];
+  modelOverrides = {};
+  extensionOAuthProviders = /* @__PURE__ */ new Map();
   usingExternalProviders = false;
   localProfileIds = /* @__PURE__ */ new Set();
   remoteCredentialEnvByProvider = /* @__PURE__ */ new Map();
   remoteCatalogByProvider = /* @__PURE__ */ new Map();
   remoteCredentialFingerprintByCatalog = /* @__PURE__ */ new Map();
-  constructor(authStorage, modelsPath = path2.join(getConfigDir(), "models.json")) {
+  constructor(authStorage, modelsPath = path3.join(getConfigDir(), "models.json")) {
     this.authStorage = authStorage;
     this.modelsPath = modelsPath;
     this.load();
@@ -45228,6 +45553,7 @@ var ModelRegistry = class {
     this.loadError = void 0;
     this.models.clear();
     this.modelOrder = [];
+    this.modelOverrides = {};
     this.configDefaults = void 0;
     this.usingExternalProviders = false;
     this.localProfileIds.clear();
@@ -45240,16 +45566,17 @@ var ModelRegistry = class {
       this.loadError = error instanceof Error ? error.message : String(error);
       return;
     }
-    if (!fs2.existsSync(this.modelsPath)) {
+    if (!fs3.existsSync(this.modelsPath)) {
       return;
     }
     try {
-      const raw = JSON.parse(fs2.readFileSync(this.modelsPath, "utf-8"));
+      const raw = JSON.parse(fs3.readFileSync(this.modelsPath, "utf-8"));
       if (raw && typeof raw === "object" && "providers" in raw) {
         throw new Error('Legacy models.json format is no longer supported. Use top-level "profiles".');
       }
       validateModelsDocumentShape(raw);
       const remotes = validatedRemoteCatalogs(raw.remoteCatalogs);
+      this.modelOverrides = raw.modelOverrides ?? {};
       const activeRemoteSecrets = configuredRemoteCredentialValues(raw);
       scrubActiveSecretsFromRemoteCaches(this.modelsPath, activeRemoteSecrets);
       const configuredProviders = Object.entries(raw.profiles || {});
@@ -45335,10 +45662,40 @@ var ModelRegistry = class {
           this.registerRemoteProfile(provider, profile, identity.apiKeyEnv, owner);
         }
       }
+      this.applyModelOverrides();
     } catch (error) {
       this.loadError = error instanceof Error ? error.message : String(error);
     }
   }
+  /**
+   * Re-apply models.json modelOverrides after any (re)materialization pass
+   * (initial load, remote catalog refresh). Overrides patch descriptive
+   * fields only; nested plain objects deep-merge, arrays/scalars replace.
+   */
+  applyModelOverrides() {
+    for (const [key, override] of Object.entries(this.modelOverrides)) {
+      const slash = key.indexOf("/");
+      if (slash <= 0) continue;
+      const provider = key.slice(0, slash);
+      const modelId = key.slice(slash + 1);
+      const existing = this.models.get(provider)?.get(modelId);
+      if (!existing) continue;
+      const patched = { ...existing };
+      if (override.name !== void 0) patched.name = override.name;
+      if (override.displayName !== void 0) patched.displayName = override.displayName;
+      if (override.reasoning !== void 0) patched.reasoning = override.reasoning;
+      if (override.input !== void 0) patched.input = [...override.input];
+      if (override.contextWindow !== void 0) patched.contextWindow = override.contextWindow;
+      if (override.maxTokens !== void 0) patched.maxTokens = override.maxTokens;
+      if (override.cost !== void 0) patched.cost = { ...existing.cost, ...override.cost };
+      if (override.headers !== void 0) patched.headers = { ...existing.headers, ...override.headers };
+      if (override.compat !== void 0) patched.compat = deepMergePlainRecords(existing.compat, override.compat);
+      if (override.cacheCapability !== void 0) patched.cacheCapability = { ...existing.cacheCapability, ...override.cacheCapability };
+      if (override.webSearch !== void 0) patched.webSearch = { ...existing.webSearch, ...override.webSearch };
+      if (override.fileCapabilities !== void 0) patched.fileCapabilities = deepMergePlainRecords(existing.fileCapabilities, override.fileCapabilities);
+      this.upsert(patched);
+    }
+  }
   registerRemoteProfile(provider, providerConfig, credentialEnv, catalogId) {
     if (this.localProfileIds.has(provider)) return;
     const existingCatalog = this.remoteCatalogByProvider.get(provider);
@@ -45398,27 +45755,28 @@ var ModelRegistry = class {
     for (const [provider, profile] of candidates) {
       this.registerRemoteProfile(provider, profile, credentialEnv, catalogId);
     }
+    this.applyModelOverrides();
   }
   writeRemoteCache(remote, fingerprint, value) {
     const directory = safeRemoteCacheDirectory(this.modelsPath, true);
     const target = remoteCachePath(this.modelsPath, remote, fingerprint);
-    if (fs2.existsSync(target)) {
-      const stat2 = fs2.lstatSync(target);
+    if (fs3.existsSync(target)) {
+      const stat2 = fs3.lstatSync(target);
       if (stat2.isSymbolicLink() || !stat2.isFile()) throw new Error(`remote catalog cache entry must be a regular file: ${target}`);
     }
-    const temporary = path2.join(directory, `.${path2.basename(target)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+    const temporary = path3.join(directory, `.${path3.basename(target)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
     try {
-      fs2.writeFileSync(temporary, `${JSON.stringify(value)}
+      fs3.writeFileSync(temporary, `${JSON.stringify(value)}
 `, { flag: "wx", mode: 384 });
-      fs2.renameSync(temporary, target);
+      fs3.renameSync(temporary, target);
       const tombstone = remoteCacheTombstonePath(this.modelsPath, remote, fingerprint);
-      if (fs2.existsSync(tombstone)) fs2.unlinkSync(tombstone);
+      if (fs3.existsSync(tombstone)) fs3.unlinkSync(tombstone);
     } finally {
-      if (fs2.existsSync(temporary)) fs2.unlinkSync(temporary);
+      if (fs3.existsSync(temporary)) fs3.unlinkSync(temporary);
     }
   }
   refreshRemoteCatalogs() {
-    const queueKey = path2.resolve(this.modelsPath);
+    const queueKey = path3.resolve(this.modelsPath);
     const previous = remoteRefreshTails.get(queueKey) ?? Promise.resolve();
     const refresh = previous.then(() => this.performRemoteCatalogRefresh());
     const tail = refresh.catch(() => void 0);
@@ -45443,14 +45801,14 @@ var ModelRegistry = class {
       this.loadError = error instanceof Error ? error.message : String(error);
       return;
     }
-    if (!fs2.existsSync(this.modelsPath)) {
+    if (!fs3.existsSync(this.modelsPath)) {
       for (const owner of new Set(this.remoteCatalogByProvider.values())) this.removeRemoteCatalogProfiles(owner);
       this.remoteCredentialFingerprintByCatalog.clear();
       return;
     }
     let config;
     try {
-      const decoded = JSON.parse(fs2.readFileSync(this.modelsPath, "utf8"));
+      const decoded = JSON.parse(fs3.readFileSync(this.modelsPath, "utf8"));
       validateModelsDocumentShape(decoded);
       config = decoded;
     } catch {
@@ -45458,6 +45816,7 @@ var ModelRegistry = class {
       this.remoteCredentialFingerprintByCatalog.clear();
       return;
     }
+    this.modelOverrides = config.modelOverrides ?? {};
     let remotes;
     try {
       remotes = validatedRemoteCatalogs(config.remoteCatalogs);
@@ -45739,11 +46098,131 @@ var ModelRegistry = class {
     if (remoteEnv) return typeof process !== "undefined" ? process.env?.[remoteEnv] : void 0;
     return this.authStorage.getApiKey(provider);
   }
+  /**
+   * Register a provider at runtime (extension API). Not persisted to
+   * models.json: runtime registrations live for the process unless the
+   * extension registers them again. Returns an unregister handle that
+   * restores the provider's previous state (models, order, env binding).
+   *
+   * When the provider already exists (local profile or remote catalog),
+   * models are merged by id: registered models upsert over existing entries
+   * with the same id; existing entries not named in `config.models` survive.
+   * baseUrl/api/headers patch every model of that provider (existing and
+   * new) when provided.
+   */
+  registerProvider(provider, config) {
+    validateExtensionProviderConfig(provider, config);
+    const previousModels = this.models.get(provider) ? new Map(this.models.get(provider)) : void 0;
+    const previousOrder = [...this.modelOrder];
+    const previousEnvVar = this.authStorage.getProviderEnvVar(provider);
+    if (config.apiKey) {
+      this.authStorage.setRuntimeApiKey(provider, config.apiKey);
+    }
+    if (config.apiKeyEnv) {
+      this.authStorage.setProviderEnvVar(provider, config.apiKeyEnv);
+    }
+    const existing = this.models.get(provider);
+    if (existing && (config.baseUrl || config.api || config.headers)) {
+      for (const model of existing.values()) {
+        this.upsert({
+          ...model,
+          baseUrl: config.baseUrl || model.baseUrl,
+          api: config.api || model.api,
+          headers: config.headers ? { ...model.headers, ...config.headers } : model.headers
+        });
+      }
+    }
+    for (const customModel of config.models ?? []) {
+      const baseModel = this.models.get(provider)?.get(customModel.id);
+      this.upsert({
+        id: customModel.id,
+        name: customModel.name || baseModel?.name || customModel.id,
+        api: config.api || baseModel?.api || "openai-completions",
+        provider,
+        baseUrl: config.baseUrl || baseModel?.baseUrl || "",
+        reasoning: customModel.reasoning ?? baseModel?.reasoning ?? false,
+        input: customModel.input || baseModel?.input || ["text"],
+        cost: customModel.cost || baseModel?.cost || { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: customModel.contextWindow || baseModel?.contextWindow || 128e3,
+        maxTokens: customModel.maxTokens || baseModel?.maxTokens || 8192,
+        apiKeyEnv: config.apiKeyEnv || baseModel?.apiKeyEnv,
+        displayName: customModel.displayName || baseModel?.displayName || provider,
+        headers: config.headers ? { ...baseModel?.headers, ...config.headers, ...customModel.headers } : customModel.headers || baseModel?.headers,
+        compat: customModel.compat || baseModel?.compat,
+        cacheCapability: customModel.cacheCapability || baseModel?.cacheCapability,
+        webSearch: customModel.webSearch || baseModel?.webSearch,
+        fileCapabilities: customModel.fileCapabilities || baseModel?.fileCapabilities
+      });
+    }
+    this.applyModelOverrides();
+    this.usingExternalProviders = true;
+    const registeredOAuth = config.oauth;
+    if (registeredOAuth) this.extensionOAuthProviders.set(provider, registeredOAuth);
+    return () => {
+      if (previousModels) this.models.set(provider, previousModels);
+      else this.models.delete(provider);
+      this.modelOrder = previousOrder;
+      this.authStorage.setRuntimeApiKey(provider, void 0);
+      this.authStorage.setProviderEnvVar(provider, previousEnvVar);
+      if (registeredOAuth) this.extensionOAuthProviders.delete(provider);
+      this.applyModelOverrides();
+    };
+  }
+  /** OAuth flow declared by an extension-registered provider, if any. */
+  getExtensionOAuth(provider) {
+    return this.extensionOAuthProviders.get(provider);
+  }
+  /**
+   * Restore persisted OAuth credentials now that extensions have registered
+   * their providers: refresh expired tokens when the extension declares
+   * refreshToken, and drop the runtime binding when a token cannot be
+   * recovered (getApiKey then reports the provider as unauthenticated).
+   * Never throws; returns per-provider outcomes for the host to surface.
+   */
+  async restorePersistedOAuth() {
+    const authStorage = this.authStorage;
+    const results = [];
+    for (const provider of authStorage.getOAuthProviderNames()) {
+      const credentials = authStorage.getOAuthCredentials(provider);
+      if (!credentials?.access) continue;
+      const expired = credentials.expires !== void 0 && credentials.expires <= Date.now() + OAUTH_RESTORE_LEEWAY_MS;
+      if (!expired) continue;
+      const oauth = this.extensionOAuthProviders.get(provider);
+      if (!oauth?.refreshToken || !credentials.refresh) {
+        authStorage.setRuntimeApiKey(provider, void 0);
+        results.push({ provider, action: "not-refreshable", detail: "token expired and no refresh flow" });
+        continue;
+      }
+      try {
+        const next = await withTimeout(
+          oauth.refreshToken({
+            access: credentials.access,
+            refresh: credentials.refresh,
+            expires: credentials.expires
+          }),
+          OAUTH_REFRESH_TIMEOUT_MS,
+          `${provider} refreshToken timed out after ${OAUTH_REFRESH_TIMEOUT_MS}ms`
+        );
+        const merged = { ...credentials, ...next };
+        authStorage.setOAuthCredentials(provider, merged);
+        authStorage.setRuntimeApiKey(provider, merged.access);
+        results.push({ provider, action: "refreshed" });
+      } catch (error) {
+        authStorage.setRuntimeApiKey(provider, void 0);
+        results.push({ provider, action: "refresh-failed", detail: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    return results;
+  }
+  /** Credential store backing this registry (for OAuth persistence). */
+  getAuthStorage() {
+    return this.authStorage;
+  }
 };
 
 // src/core/settings-manager.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 var SettingsManager = class {
   settingsPath;
   legacyConfigPath;
@@ -45757,9 +46236,9 @@ var SettingsManager = class {
     this.legacyConfig = this.loadLegacyConfigFile();
   }
   readJson(filePath) {
-    if (!fs3.existsSync(filePath)) return null;
+    if (!fs4.existsSync(filePath)) return null;
     try {
-      return JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
     } catch {
       return null;
     }
@@ -45771,19 +46250,19 @@ var SettingsManager = class {
     return this.readJson(this.legacyConfigPath) || {};
   }
   ensureDir() {
-    fs3.mkdirSync(getConfigDir(), { recursive: true });
+    fs4.mkdirSync(getConfigDir(), { recursive: true });
   }
   writeSettings() {
     this.ensureDir();
-    fs3.writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2));
+    fs4.writeFileSync(this.settingsPath, JSON.stringify(this.settings, null, 2));
   }
   writeSettingsValue(settings) {
     this.ensureDir();
-    fs3.writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2));
+    fs4.writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2));
   }
   writeLegacyConfig() {
     this.ensureDir();
-    fs3.writeFileSync(this.legacyConfigPath, JSON.stringify(this.legacyConfig, null, 2));
+    fs4.writeFileSync(this.legacyConfigPath, JSON.stringify(this.legacyConfig, null, 2));
   }
   getLegacyApiKey() {
     return this.legacyConfig.apiKey;
@@ -45832,6 +46311,9 @@ var SettingsManager = class {
     }
     return "auto";
   }
+  getBellNotificationsEnabled() {
+    return this.settings.notifications?.bell !== false;
+  }
   // ==========================================================================
   // Extension enablement (user ~/.pie/settings.json + project ./.pie/settings.json)
   // ==========================================================================
@@ -45840,8 +46322,8 @@ var SettingsManager = class {
   }
   writeProjectSettings(cwd, settings) {
     const settingsPath = getProjectSettingsPath(cwd);
-    fs3.mkdirSync(path3.dirname(settingsPath), { recursive: true });
-    fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    fs4.mkdirSync(path4.dirname(settingsPath), { recursive: true });
+    fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
   }
   /** Raw extension enablement map for one scope. */
   getExtensionSettings(scope = "user", cwd = process.cwd()) {
@@ -45915,19 +46397,19 @@ function checkShell() {
 }
 function canWriteDirectory(dir) {
   try {
-    fs4.mkdirSync(dir, { recursive: true });
-    const probe = path4.join(dir, `.pie-doctor-${process.pid}-${Date.now()}`);
-    fs4.writeFileSync(probe, "ok", "utf8");
-    fs4.rmSync(probe, { force: true });
+    fs5.mkdirSync(dir, { recursive: true });
+    const probe = path5.join(dir, `.pie-doctor-${process.pid}-${Date.now()}`);
+    fs5.writeFileSync(probe, "ok", "utf8");
+    fs5.rmSync(probe, { force: true });
     return { ok: true };
   } catch (error) {
     return { ok: false, error: error instanceof Error ? error.message : String(error) };
   }
 }
 function isExecutable(candidate) {
-  if (!candidate || !fs4.existsSync(candidate)) return false;
+  if (!candidate || !fs5.existsSync(candidate)) return false;
   try {
-    fs4.accessSync(candidate, fs4.constants.X_OK);
+    fs5.accessSync(candidate, fs5.constants.X_OK);
     return true;
   } catch {
     return os.platform() === "win32";
@@ -45937,7 +46419,7 @@ function findOnPath(names) {
   for (const dir of (process.env.PATH || "").split(delimiter)) {
     if (!dir) continue;
     for (const name of names) {
-      const candidate = path4.join(dir, name);
+      const candidate = path5.join(dir, name);
       if (isExecutable(candidate)) return candidate;
     }
   }
@@ -45953,10 +46435,10 @@ function findDoctorChromeExecutable() {
     "/Applications/Chromium.app/Contents/MacOS/Chromium",
     "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
   ] : os.platform() === "win32" ? [
-    path4.join(process.env.PROGRAMFILES || "C:\\Program Files", "Google", "Chrome", "Application", "chrome.exe"),
-    path4.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Google", "Chrome", "Application", "chrome.exe"),
-    path4.join(process.env.LOCALAPPDATA || path4.join(home, "AppData", "Local"), "Google", "Chrome", "Application", "chrome.exe"),
-    path4.join(process.env.PROGRAMFILES || "C:\\Program Files", "Microsoft", "Edge", "Application", "msedge.exe")
+    path5.join(process.env.PROGRAMFILES || "C:\\Program Files", "Google", "Chrome", "Application", "chrome.exe"),
+    path5.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Google", "Chrome", "Application", "chrome.exe"),
+    path5.join(process.env.LOCALAPPDATA || path5.join(home, "AppData", "Local"), "Google", "Chrome", "Application", "chrome.exe"),
+    path5.join(process.env.PROGRAMFILES || "C:\\Program Files", "Microsoft", "Edge", "Application", "msedge.exe")
   ] : [
     "/usr/bin/google-chrome",
     "/usr/bin/google-chrome-stable",
@@ -46005,7 +46487,7 @@ function checkPlaywrightBrowser() {
   } catch {
     executablePath = void 0;
   }
-  if (executablePath && fs4.existsSync(executablePath)) {
+  if (executablePath && fs5.existsSync(executablePath)) {
     return {
       id: "playwright_browser",
       label: "Playwright browser",
@@ -46014,7 +46496,7 @@ function checkPlaywrightBrowser() {
       details: { executablePath }
     };
   }
-  const skillWrapper = path4.join(getBuiltinDir(), "skills", "browser-tools", "playwright-cli.js");
+  const skillWrapper = path5.join(getBuiltinDir(), "skills", "browser-tools", "playwright-cli.js");
   return {
     id: "playwright_browser",
     label: "Playwright browser",
@@ -46045,8 +46527,8 @@ function isLiveUnityInstance(instance, nowUnix = Math.floor(Date.now() / 1e3)) {
   return isProcessAlive(Number(instance.pid || 0));
 }
 function checkUnityRegistry() {
-  const registryDir = path4.join(os.homedir(), ".pie-unity", "instances");
-  if (!fs4.existsSync(registryDir)) {
+  const registryDir = path5.join(os.homedir(), ".pie-unity", "instances");
+  if (!fs5.existsSync(registryDir)) {
     return {
       id: "unity_bridge",
       label: "Unity bridge",
@@ -46057,12 +46539,12 @@ function checkUnityRegistry() {
   }
   try {
     const nowUnix = Math.floor(Date.now() / 1e3);
-    const files = fs4.readdirSync(registryDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path4.join(registryDir, entry.name));
+    const files = fs5.readdirSync(registryDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path5.join(registryDir, entry.name));
     let malformedFiles = 0;
     let invalidFiles = 0;
     const liveInstances = files.map((filePath) => {
       try {
-        const parsed = JSON.parse(fs4.readFileSync(filePath, "utf8").replace(/^\uFEFF/, ""));
+        const parsed = JSON.parse(fs5.readFileSync(filePath, "utf8").replace(/^\uFEFF/, ""));
         if (!isRecord(parsed)) {
           invalidFiles += 1;
           return null;
@@ -46136,13 +46618,13 @@ async function runDoctor() {
   const packageDir = getPackageDir();
   let dir = packageDir;
   let lockPath;
-  while (dir !== path4.dirname(dir)) {
-    const candidate = path4.join(dir, "package-lock.json");
-    if (fs4.existsSync(candidate)) {
+  while (dir !== path5.dirname(dir)) {
+    const candidate = path5.join(dir, "package-lock.json");
+    if (fs5.existsSync(candidate)) {
       lockPath = candidate;
       break;
     }
-    dir = path4.dirname(dir);
+    dir = path5.dirname(dir);
   }
   checks.push({
     id: "package_lock",
@@ -46164,7 +46646,7 @@ async function runDoctor() {
       message: result.ok ? `${dirPath} is writable.` : `${dirPath} is not writable: ${result.error}`
     });
   }
-  const authStorage = new AuthStorage();
+  const authStorage = AuthStorage.create();
   const registry = new ModelRegistry(authStorage);
   const loadError = registry.getLoadError();
   const models = registry.getAll();
@@ -46305,10 +46787,10 @@ Disable or narrow capabilities:
 }
 
 // src/commands/models-config.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 function getDefaultModelsPath() {
-  return path5.join(getConfigDir(), "models.json");
+  return path6.join(getConfigDir(), "models.json");
 }
 function createModelsTemplate() {
   const template = {
@@ -46403,7 +46885,7 @@ function createModelsTemplate() {
 `;
 }
 function resolveModelsPath(input) {
-  return input ? path5.resolve(input) : getDefaultModelsPath();
+  return input ? path6.resolve(input) : getDefaultModelsPath();
 }
 function initModelsConfig(options = {}) {
   const targetPath = resolveModelsPath(options.path);
@@ -46411,16 +46893,16 @@ function initModelsConfig(options = {}) {
   if (options.stdout) {
     return { path: targetPath, content, wrote: false };
   }
-  if (fs5.existsSync(targetPath) && !options.force) {
+  if (fs6.existsSync(targetPath) && !options.force) {
     throw new Error(`models.json already exists: ${targetPath}. Use --force to overwrite, or --stdout to print the template.`);
   }
-  fs5.mkdirSync(path5.dirname(targetPath), { recursive: true });
-  fs5.writeFileSync(targetPath, content, "utf8");
+  fs6.mkdirSync(path6.dirname(targetPath), { recursive: true });
+  fs6.writeFileSync(targetPath, content, "utf8");
   return { path: targetPath, content, wrote: true };
 }
 function validateModelsConfig(options = {}) {
   const modelsPath = resolveModelsPath(options.path);
-  if (!fs5.existsSync(modelsPath)) {
+  if (!fs6.existsSync(modelsPath)) {
     return {
       ok: false,
       path: modelsPath,
@@ -46429,7 +46911,7 @@ function validateModelsConfig(options = {}) {
       modelCount: 0
     };
   }
-  const authStorage = new AuthStorage();
+  const authStorage = AuthStorage.create();
   const registry = new ModelRegistry(authStorage, modelsPath);
   const loadError = registry.getLoadError();
   if (loadError) {
@@ -46476,7 +46958,7 @@ function validateModelsConfig(options = {}) {
   };
 }
 async function probeModelsConfig(options) {
-  const registry = new ModelRegistry(new AuthStorage(), resolveModelsPath(options.path));
+  const registry = new ModelRegistry(AuthStorage.create(), resolveModelsPath(options.path));
   const loadError = registry.getLoadError();
   if (loadError) {
     return {
@@ -46569,7 +47051,7 @@ function parseModelsCommandArgs(args) {
 }
 
 // src/commands/sessions.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 
 // src/session-control.ts
 var SessionControlError = class extends Error {
@@ -46714,15 +47196,15 @@ function buildForkResult(params) {
 }
 function pathToEntry(data, entryId) {
   const byId = new Map(data.entries.map((entry) => [entry.id, entry]));
-  const path31 = [];
+  const path33 = [];
   let current = entryId;
   while (current) {
     const entry = byId.get(current);
     if (!entry) return [];
-    path31.unshift(entry);
+    path33.unshift(entry);
     current = entry.parentId;
   }
-  return path31;
+  return path33;
 }
 function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
@@ -46968,7 +47450,7 @@ function cwdMatches(sessionCwd, requestedCwd) {
 }
 function realpathOrInput(value) {
   try {
-    return fs6.realpathSync.native(value);
+    return fs7.realpathSync.native(value);
   } catch {
     return value;
   }
@@ -47057,9 +47539,9 @@ function isRecord2(value) {
 }
 
 // src/extensions/loader.ts
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os2 from "os";
-import * as path6 from "path";
+import * as path7 from "path";
 import { pathToFileURL } from "node:url";
 
 // src/command-tree.ts
@@ -47072,19 +47554,19 @@ var CommandTree = class {
    *   register(["session", "new"], { description, handler })
    *   register(["tools", "subagent", "spawn", "local"], { description, handler })
    */
-  register(path31, info) {
-    if (path31.length === 0) {
+  register(path33, info) {
+    if (path33.length === 0) {
       throw new Error("Command path cannot be empty");
     }
     let current = this.root;
     const fullPath = [];
-    for (let i = 0; i < path31.length; i++) {
-      const segment = path31[i];
+    for (let i = 0; i < path33.length; i++) {
+      const segment = path33[i];
       fullPath.push(segment);
       if (!current.children) {
         current.children = [];
       }
-      const isLast = i === path31.length - 1;
+      const isLast = i === path33.length - 1;
       let node = current.children.find((n) => n.name === segment);
       if (!node) {
         node = {
@@ -47114,31 +47596,31 @@ var CommandTree = class {
   /**
    * Find a node by path
    */
-  find(path31) {
-    if (path31.length === 0) {
+  find(path33) {
+    if (path33.length === 0) {
       return this.root;
     }
-    const key = path31.join("/");
+    const key = path33.join("/");
     return this.pathCache.get(key) || null;
   }
   /**
    * Get children of a path
    */
-  getChildren(path31) {
-    const node = this.find(path31);
+  getChildren(path33) {
+    const node = this.find(path33);
     return (node?.children || []).filter((child) => !child.hidden);
   }
   /**
    * Check if a path exists (as category or command)
    */
-  exists(path31) {
-    return this.find(path31) !== null;
+  exists(path33) {
+    return this.find(path33) !== null;
   }
   /**
    * Check if path is a category (has children)
    */
-  isCategory(path31) {
-    const node = this.find(path31);
+  isCategory(path33) {
+    const node = this.find(path33);
     return node?.isCategory || false;
   }
   /**
@@ -47217,8 +47699,8 @@ var CommandTree = class {
    * Supports dot notation: "tools.subagent.spawn.local"
    */
   registerFromPath(pathStr, info) {
-    const path31 = pathStr.split(/[./]/).filter(Boolean);
-    this.register(path31, info);
+    const path33 = pathStr.split(/[./]/).filter(Boolean);
+    this.register(path33, info);
   }
 };
 var commandTree = new CommandTree();
@@ -47332,6 +47814,33 @@ function createExtensionContext(extension, cwd, uiContext, abortFn, isIdleFn, ha
     setSessionMetadata(key, value) {
       actions?.setSessionMetadata?.(key, value);
     },
+    appendEntry(customType, data) {
+      if (!actions?.appendEntry) throw new Error("appendEntry is not available in this host mode");
+      return actions.appendEntry(customType, data);
+    },
+    setLabel(entryId, label) {
+      if (!actions?.setLabel) throw new Error("setLabel is not available in this host mode");
+      return actions.setLabel(entryId, label);
+    },
+    setSessionName(name) {
+      if (!actions?.setSessionName) throw new Error("setSessionName is not available in this host mode");
+      return actions.setSessionName(name);
+    },
+    getSessionName() {
+      return actions?.getSessionName?.();
+    },
+    registerProvider(name, config) {
+      if (!actions?.registerProvider) throw new Error("registerProvider is not available in this host mode");
+      return actions.registerProvider(name, config);
+    },
+    async loginProvider(name) {
+      if (!actions?.loginProvider) throw new Error("loginProvider is not available in this host mode");
+      return actions.loginProvider(name);
+    },
+    async reload() {
+      if (!actions?.reload) throw new Error("reload is not available in this host mode");
+      return actions.reload();
+    },
     get yoloMode() {
       return actions?.yoloMode ?? false;
     }
@@ -47353,19 +47862,19 @@ function createExtension(extensionPath, resolvedPath, identity, source) {
 }
 function expandPath(p) {
   if (p.startsWith("~/")) {
-    return path6.join(os2.homedir(), p.slice(2));
+    return path7.join(os2.homedir(), p.slice(2));
   }
   if (p.startsWith("~")) {
-    return path6.join(os2.homedir(), p.slice(1));
+    return path7.join(os2.homedir(), p.slice(1));
   }
   return p;
 }
 function resolvePath(extPath, cwd) {
   const expanded = expandPath(extPath);
-  if (path6.isAbsolute(expanded)) {
+  if (path7.isAbsolute(expanded)) {
     return expanded;
   }
-  return path6.resolve(cwd, expanded);
+  return path7.resolve(cwd, expanded);
 }
 async function loadExtensionModule(extensionPath) {
   try {
@@ -47385,14 +47894,14 @@ function normalizeExtensionImportPath(extensionPath) {
   if (/^[a-zA-Z]:[\\/]/.test(extensionPath)) {
     return `file:///${extensionPath.replace(/\\/g, "/")}`;
   }
-  if (path6.isAbsolute(extensionPath)) {
+  if (path7.isAbsolute(extensionPath)) {
     return pathToFileURL(extensionPath).href;
   }
   return extensionPath;
 }
 async function loadExtension(extensionPath, cwd, uiContext, abortFn, isIdleFn, hasUI, actions, discovered) {
   const resolvedPath = resolvePath(extensionPath, cwd);
-  if (!fs7.existsSync(resolvedPath)) {
+  if (!fs8.existsSync(resolvedPath)) {
     return { extension: null, error: `Extension not found: ${extensionPath}` };
   }
   try {
@@ -47413,17 +47922,17 @@ async function loadExtension(extensionPath, cwd, uiContext, abortFn, isIdleFn, h
   }
 }
 function discoverExtensionsInDir(dir, source) {
-  if (!fs7.existsSync(dir)) {
+  if (!fs8.existsSync(dir)) {
     return [];
   }
   const discovered = [];
   try {
-    const entries = fs7.readdirSync(dir, { withFileTypes: true });
+    const entries = fs8.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.endsWith(".disabled")) {
         continue;
       }
-      const entryPath = path6.join(dir, entry.name);
+      const entryPath = path7.join(dir, entry.name);
       if (entry.isFile() && (entry.name.endsWith(".cjs") || entry.name.endsWith(".js") || entry.name.endsWith(".ts"))) {
         discovered.push({
           entryPath,
@@ -47433,13 +47942,13 @@ function discoverExtensionsInDir(dir, source) {
         continue;
       }
       if (entry.isDirectory()) {
-        const packageJsonPath = path6.join(entryPath, "package.json");
+        const packageJsonPath = path7.join(entryPath, "package.json");
         let packageIdentity;
         let packageDescription;
         let packageMainPath;
-        if (fs7.existsSync(packageJsonPath)) {
+        if (fs8.existsSync(packageJsonPath)) {
           try {
-            const pkg = JSON.parse(fs7.readFileSync(packageJsonPath, "utf-8"));
+            const pkg = JSON.parse(fs8.readFileSync(packageJsonPath, "utf-8"));
             const manifest = pkg.pie && typeof pkg.pie === "object" && !Array.isArray(pkg.pie) ? pkg.pie : void 0;
             packageIdentity = resolveExtensionIdentity({
               pieName: typeof manifest?.name === "string" ? manifest.name : void 0,
@@ -47448,8 +47957,8 @@ function discoverExtensionsInDir(dir, source) {
             });
             packageDescription = typeof pkg.description === "string" ? pkg.description : void 0;
             if (typeof manifest?.main === "string" && manifest.main.trim().length > 0) {
-              const candidate = path6.resolve(entryPath, manifest.main);
-              if (fs7.existsSync(candidate)) {
+              const candidate = path7.resolve(entryPath, manifest.main);
+              if (fs8.existsSync(candidate)) {
                 packageMainPath = candidate;
               }
             }
@@ -47465,8 +47974,8 @@ function discoverExtensionsInDir(dir, source) {
           });
           continue;
         }
-        const indexCjs = path6.join(entryPath, "index.cjs");
-        if (fs7.existsSync(indexCjs)) {
+        const indexCjs = path7.join(entryPath, "index.cjs");
+        if (fs8.existsSync(indexCjs)) {
           discovered.push({
             entryPath: indexCjs,
             source,
@@ -47475,8 +47984,8 @@ function discoverExtensionsInDir(dir, source) {
           });
           continue;
         }
-        const indexJs = path6.join(entryPath, "index.js");
-        if (fs7.existsSync(indexJs)) {
+        const indexJs = path7.join(entryPath, "index.js");
+        if (fs8.existsSync(indexJs)) {
           discovered.push({
             entryPath: indexJs,
             source,
@@ -47485,8 +47994,8 @@ function discoverExtensionsInDir(dir, source) {
           });
           continue;
         }
-        const indexTs = path6.join(entryPath, "index.ts");
-        if (fs7.existsSync(indexTs)) {
+        const indexTs = path7.join(entryPath, "index.ts");
+        if (fs8.existsSync(indexTs)) {
           discovered.push({
             entryPath: indexTs,
             source,
@@ -47507,21 +48016,21 @@ function collectDiscoveredExtensions(configuredPaths, cwd, options) {
   const errors = [];
   if (!options?.noExtensions) {
     if (!options?.noBuiltinExtensions) {
-      const builtinExtDir = path6.join(getBuiltinDir(), "extensions");
+      const builtinExtDir = path7.join(getBuiltinDir(), "extensions");
       discovered.push(...discoverExtensionsInDir(builtinExtDir, "builtin"));
     }
-    const globalExtDir = path6.join(os2.homedir(), ".pie", "extensions");
+    const globalExtDir = path7.join(os2.homedir(), ".pie", "extensions");
     discovered.push(...discoverExtensionsInDir(globalExtDir, "global"));
-    const localExtDir = path6.join(cwd, ".pie", "extensions");
+    const localExtDir = path7.join(cwd, ".pie", "extensions");
     discovered.push(...discoverExtensionsInDir(localExtDir, "project"));
   }
   for (const p of configuredPaths) {
     const resolved = resolvePath(p, cwd);
-    if (!fs7.existsSync(resolved)) {
+    if (!fs8.existsSync(resolved)) {
       errors.push({ path: p, error: `Extension path not found: ${p}` });
       continue;
     }
-    if (!fs7.statSync(resolved).isDirectory()) {
+    if (!fs8.statSync(resolved).isDirectory()) {
       errors.push({ path: p, error: `Extension path must be a directory: ${p}` });
       continue;
     }
@@ -47612,6 +48121,7 @@ function convertExtensionTools(extensions, customExecutors) {
         label: tool.label ?? name,
         description: tool.description,
         parameters: tool.parameters,
+        renderHint: tool.renderHint,
         execute: async (toolCallId, args, signal, onUpdate) => {
           debugLog("ext-tool", `${name} EXECUTE START`, {
             toolCallId: toolCallId.slice(0, 8),
@@ -47802,6 +48312,9 @@ Enablement overrides are stored sparsely; absent entries default to enabled.
 Project scope writes ./.pie/settings.json and overrides user scope.`);
 }
 
+// src/interactive-mode.ts
+import * as os8 from "os";
+
 // ../../packages/tui/src/fuzzy.ts
 function fuzzyMatch(query, text) {
   const queryLower = query.toLowerCase();
@@ -49352,9 +49865,9 @@ var KillRing = class {
 };
 
 // ../../packages/tui/src/tui.ts
-import * as fs8 from "node:fs";
+import * as fs9 from "node:fs";
 import * as os3 from "node:os";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 
 // ../../packages/tui/src/terminal-image.ts
 var cachedCapabilities = null;
@@ -50030,11 +50543,11 @@ var TUI = class extends Container {
     const debugRedraw = process.env.PIE_DEBUG_REDRAW === "1";
     const logRedraw = (reason) => {
       if (!debugRedraw) return;
-      const logPath = path7.join(os3.homedir(), ".pie", "logs", "pie-cli.log");
-      fs8.mkdirSync(path7.dirname(logPath), { recursive: true });
+      const logPath = path8.join(os3.homedir(), ".pie", "logs", "pie-cli.log");
+      fs9.mkdirSync(path8.dirname(logPath), { recursive: true });
       const msg = `[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [ui] fullRender: ${reason} (prev=${this.previousLines.length}, new=${newLines.length}, height=${height})
 `;
-      fs8.appendFileSync(logPath, msg);
+      fs9.appendFileSync(logPath, msg);
     };
     if (this.previousLines.length === 0 && !widthChanged) {
       logRedraw("first render");
@@ -50127,7 +50640,7 @@ var TUI = class extends Container {
       const line = newLines[i];
       const isImage = isImageLine(line);
       if (!isImage && visibleWidth(line) > width) {
-        const crashLogPath = path7.join(os3.homedir(), ".pie", "pie-crash.log");
+        const crashLogPath = path8.join(os3.homedir(), ".pie", "pie-crash.log");
         const crashData = [
           `Crash at ${(/* @__PURE__ */ new Date()).toISOString()}`,
           `Terminal width: ${width}`,
@@ -50137,8 +50650,8 @@ var TUI = class extends Container {
           ...newLines.map((l, idx) => `[${idx}] (w=${visibleWidth(l)}) ${l}`),
           ""
         ].join("\n");
-        fs8.mkdirSync(path7.dirname(crashLogPath), { recursive: true });
-        fs8.writeFileSync(crashLogPath, crashData);
+        fs9.mkdirSync(path8.dirname(crashLogPath), { recursive: true });
+        fs9.writeFileSync(crashLogPath, crashData);
         this.stop();
         const errorMsg = [
           `Rendered line ${i} exceeds terminal width (${visibleWidth(line)} > ${width}).`,
@@ -50168,8 +50681,8 @@ var TUI = class extends Container {
     buffer += "\x1B[?2026l";
     if (process.env.PIE_TUI_DEBUG === "1") {
       const debugDir = "/tmp/tui";
-      fs8.mkdirSync(debugDir, { recursive: true });
-      const debugPath = path7.join(debugDir, `render-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
+      fs9.mkdirSync(debugDir, { recursive: true });
+      const debugPath = path8.join(debugDir, `render-${Date.now()}-${Math.random().toString(36).slice(2)}.log`);
       const debugData = [
         `firstChanged: ${firstChanged}`,
         `viewportTop: ${viewportTop}`,
@@ -50192,7 +50705,7 @@ var TUI = class extends Container {
         "=== buffer ===",
         JSON.stringify(buffer)
       ].join("\n");
-      fs8.writeFileSync(debugPath, debugData);
+      fs9.writeFileSync(debugPath, debugData);
     }
     this.terminal.write(buffer);
     this.cursorRow = Math.max(0, newLines.length - 1);
@@ -54383,7 +54896,7 @@ var StdinBuffer = class extends EventEmitter {
 };
 
 // ../../packages/tui/src/terminal.ts
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import koffi from "koffi";
 var ProcessTerminal = class {
   wasRaw = false;
@@ -54508,7 +55021,7 @@ var ProcessTerminal = class {
         const timeLeft = endTime - now;
         if (timeLeft <= 0) break;
         if (now - lastDataTime >= idleMs) break;
-        await new Promise((resolve6) => setTimeout(resolve6, Math.min(idleMs, timeLeft)));
+        await new Promise((resolve7) => setTimeout(resolve7, Math.min(idleMs, timeLeft)));
       }
     } finally {
       process.stdin.removeListener("data", onData);
@@ -54544,7 +55057,7 @@ var ProcessTerminal = class {
     process.stdout.write(data);
     if (this.writeLogPath) {
       try {
-        fs9.appendFileSync(this.writeLogPath, data, { encoding: "utf8" });
+        fs10.appendFileSync(this.writeLogPath, data, { encoding: "utf8" });
       } catch {
       }
     }
@@ -54618,6 +55131,8 @@ var ExtensionRunner = class {
   actions;
   contextActions;
   hasUI;
+  /** Unregister handles created through this runner, revoked on reload/teardown. */
+  unregisterHandles = [];
   constructor(extensions, actions, contextActions, hasUI = true) {
     this.extensions = extensions;
     this.actions = actions;
@@ -54649,6 +55164,39 @@ var ExtensionRunner = class {
     this.uiContext = uiContext;
     this.hasUI = true;
   }
+  /**
+   * Wrap an unregister handle so this runner can revoke it during
+   * reload/teardown even if the extension drops the handle it was returned.
+   * The wrapper is idempotent.
+   */
+  trackUnregisterHandle(unregister) {
+    const entry = { invoked: false, unregister };
+    this.unregisterHandles.push(entry);
+    return () => {
+      if (entry.invoked) return;
+      entry.invoked = true;
+      unregister();
+      const index = this.unregisterHandles.indexOf(entry);
+      if (index >= 0) this.unregisterHandles.splice(index, 1);
+    };
+  }
+  /**
+   * Revoke every provider registration made through this runner (runtime
+   * reload / teardown). Old extension instances must not leave providers,
+   * OAuth flows, or ambient state registered behind them.
+   */
+  revokeRegistrations() {
+    const pending = this.unregisterHandles.splice(0);
+    for (const entry of pending) {
+      if (entry.invoked) continue;
+      entry.invoked = true;
+      try {
+        entry.unregister();
+      } catch (error) {
+        console.warn("[Extension] unregister provider failed during reload:", error);
+      }
+    }
+  }
   /**
    * Get all registered tools from all extensions.
    */
@@ -54739,10 +55287,35 @@ var ExtensionRunner = class {
       },
       getAllTools: () => runner.actions.getAllTools(),
       getRuntimeTools: () => runner.actions.getRuntimeTools(),
-      resolveModelClass: (modelClass) => runner.actions.resolveModelClass?.(modelClass),
+      resolveModelClass: (modelClass) => runner.actions.resolveModelClass?.(modelClass) ?? {},
       getMessages: () => runner.actions.getMessages(),
       getSessionMetadata: () => runner.actions.getSessionMetadata(),
       setSessionMetadata: (key, value) => runner.actions.setSessionMetadata(key, value),
+      appendEntry: (customType, data) => {
+        if (!runner.actions.appendEntry) throw new Error("appendEntry is not available in this host mode");
+        return runner.actions.appendEntry(customType, data);
+      },
+      setLabel: (entryId, label) => {
+        if (!runner.actions.setLabel) throw new Error("setLabel is not available in this host mode");
+        return runner.actions.setLabel(entryId, label);
+      },
+      setSessionName: (name) => {
+        if (!runner.actions.setSessionName) throw new Error("setSessionName is not available in this host mode");
+        return runner.actions.setSessionName(name);
+      },
+      getSessionName: () => runner.actions.getSessionName?.(),
+      registerProvider: (name, config) => {
+        if (!runner.actions.registerProvider) throw new Error("registerProvider is not available in this host mode");
+        return runner.trackUnregisterHandle(runner.actions.registerProvider(name, config));
+      },
+      loginProvider: async (name) => {
+        if (!runner.actions.loginProvider) throw new Error("loginProvider is not available in this host mode");
+        return runner.actions.loginProvider(name);
+      },
+      reload: async () => {
+        if (!runner.actions.reload) throw new Error("reload is not available in this host mode");
+        return runner.actions.reload();
+      },
       get yoloMode() {
         return runner.actions.yoloMode ?? false;
       }
@@ -54822,6 +55395,81 @@ var ExtensionRunner = class {
       isError: currentEvent.isError ?? event.isError
     };
   }
+  /**
+   * Emit session:before_switch. The first cancel wins; default allows.
+   */
+  async emitSessionBeforeSwitch(event) {
+    const ctx = this.createContext();
+    for (const ext of this.extensions) {
+      const handlers = ext.handlers.get("session:before_switch");
+      if (!handlers || handlers.length === 0) continue;
+      for (const handler of handlers) {
+        try {
+          const result = await handler(event, ctx);
+          if (result && typeof result === "object" && result.cancel === true) return { cancel: true };
+        } catch (err) {
+          if (process.env.PIE_VERBOSE) {
+            console.warn(`[Runner] session:before_switch handler failed in ${ext.path}:`, err);
+          }
+        }
+      }
+    }
+    return {};
+  }
+  /**
+   * Emit session:before_compact. The first cancel wins; the first custom
+   * summary wins; default runs the built-in summarizer.
+   */
+  async emitSessionBeforeCompact(event) {
+    const ctx = this.createContext();
+    for (const ext of this.extensions) {
+      const handlers = ext.handlers.get("session:before_compact");
+      if (!handlers || handlers.length === 0) continue;
+      for (const handler of handlers) {
+        try {
+          const result = await handler(event, ctx);
+          if (!result || typeof result !== "object") continue;
+          if (result.cancel === true) return { cancel: true };
+          if (typeof result.summary === "string" && result.summary.trim()) return { summary: result.summary };
+        } catch (err) {
+          if (process.env.PIE_VERBOSE) {
+            console.warn(`[Runner] session:before_compact handler failed in ${ext.path}:`, err);
+          }
+        }
+      }
+    }
+    return {};
+  }
+  /**
+   * Emit terminal:input to all extensions. Transforms chain through handlers
+   * in registration order (each handler sees the previous transform); a
+   * consume result stops the chain and wins. Default: continue unchanged.
+   */
+  async emitTerminalInput(event) {
+    const ctx = this.createContext();
+    let current = { action: "continue" };
+    let text = event.text;
+    for (const ext of this.extensions) {
+      const handlers = ext.handlers.get("terminal:input");
+      if (!handlers || handlers.length === 0) continue;
+      for (const handler of handlers) {
+        try {
+          const result = await handler({ ...event, text }, ctx);
+          if (!result || typeof result !== "object" || !("action" in result)) continue;
+          if (result.action === "consume") return { action: "consume" };
+          if (result.action === "transform" && typeof result.text === "string") {
+            text = result.text;
+            current = { action: "transform", text };
+          }
+        } catch (err) {
+          if (process.env.PIE_VERBOSE) {
+            console.warn(`[Runner] terminal:input handler failed in ${ext.path}:`, err);
+          }
+        }
+      }
+    }
+    return current;
+  }
   /**
    * Emit a generic event to all extensions.
    */
@@ -54959,8 +55607,8 @@ function wrapToolsWithExtensions(tools, runner) {
 }
 
 // src/keybindings.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { join as join7 } from "path";
 var DEFAULT_APP_KEYBINDINGS = {
   interrupt: "escape",
   clear: "ctrl+c",
@@ -55024,7 +55672,7 @@ var KeybindingsManager = class _KeybindingsManager {
    * Create from config file and set up editor keybindings.
    */
   static create(agentDir = getAgentDir()) {
-    const configPath = join6(agentDir, "keybindings.json");
+    const configPath = join7(agentDir, "keybindings.json");
     const config = _KeybindingsManager.loadFromFile(configPath);
     const manager = new _KeybindingsManager(config);
     const editorConfig = {};
@@ -55042,10 +55690,10 @@ var KeybindingsManager = class _KeybindingsManager {
   static inMemory(config = {}) {
     return new _KeybindingsManager(config);
   }
-  static loadFromFile(path31) {
-    if (!existsSync7(path31)) return {};
+  static loadFromFile(path33) {
+    if (!existsSync8(path33)) return {};
     try {
-      return JSON.parse(readFileSync6(path31, "utf-8"));
+      return JSON.parse(readFileSync7(path33, "utf-8"));
     } catch {
       return {};
     }
@@ -55094,19 +55742,19 @@ var KeybindingsManager = class _KeybindingsManager {
 };
 
 // src/project-knowledge.ts
-import fs10 from "node:fs";
-import path8 from "node:path";
+import fs11 from "node:fs";
+import path9 from "node:path";
 function collectAncestorAgentsFiles(cwd) {
-  const resolvedCwd = path8.resolve(cwd || process.cwd());
+  const resolvedCwd = path9.resolve(cwd || process.cwd());
   const projectRoot = resolveCliProjectRoot(resolvedCwd);
   const candidates = [];
   let current = resolvedCwd;
   while (true) {
-    candidates.unshift(path8.join(current, AGENTS_CONTEXT_FILE_NAME));
+    candidates.unshift(path9.join(current, AGENTS_CONTEXT_FILE_NAME));
     if (current === projectRoot) {
       break;
     }
-    const parent = path8.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) {
       break;
     }
@@ -55114,13 +55762,13 @@ function collectAncestorAgentsFiles(cwd) {
   }
   const files = [];
   for (const candidate of candidates) {
-    if (!fs10.existsSync(candidate)) {
+    if (!fs11.existsSync(candidate)) {
       continue;
     }
     try {
       files.push({
-        path: path8.relative(resolvedCwd, candidate) || AGENTS_CONTEXT_FILE_NAME,
-        content: fs10.readFileSync(candidate, "utf-8")
+        path: path9.relative(resolvedCwd, candidate) || AGENTS_CONTEXT_FILE_NAME,
+        content: fs11.readFileSync(candidate, "utf-8")
       });
     } catch {
     }
@@ -55132,14 +55780,14 @@ function buildCliProjectContextSection(cwd) {
 }
 
 // src/file-access-context.ts
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 function uniqueNormalizedPaths(paths) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const entry of paths) {
     const trimmed = String(entry || "").trim();
     if (!trimmed) continue;
-    const normalized = path9.normalize(trimmed);
+    const normalized = path10.normalize(trimmed);
     if (seen.has(normalized)) continue;
     seen.add(normalized);
     result.push(normalized);
@@ -55158,8 +55806,8 @@ function buildCliFileAccessOptions(params) {
 }
 
 // src/theme/theme.ts
-import * as fs11 from "node:fs";
-import * as path10 from "node:path";
+import * as fs12 from "node:fs";
+import * as path11 from "node:path";
 
 // ../../node_modules/@sinclair/typebox/build/esm/compiler/compiler.mjs
 var TypeCheck = class {
@@ -56046,11 +56694,11 @@ var BUILTIN_THEMES;
 function getBuiltinThemes() {
   if (!BUILTIN_THEMES) {
     const themesDir = getThemesDir();
-    const darkPath = path10.join(themesDir, "dark.json");
-    const lightPath = path10.join(themesDir, "light.json");
+    const darkPath = path11.join(themesDir, "dark.json");
+    const lightPath = path11.join(themesDir, "light.json");
     BUILTIN_THEMES = {
-      dark: JSON.parse(fs11.readFileSync(darkPath, "utf-8")),
-      light: JSON.parse(fs11.readFileSync(lightPath, "utf-8"))
+      dark: JSON.parse(fs12.readFileSync(darkPath, "utf-8")),
+      light: JSON.parse(fs12.readFileSync(lightPath, "utf-8"))
     };
   }
   return BUILTIN_THEMES;
@@ -56058,8 +56706,8 @@ function getBuiltinThemes() {
 function getAvailableThemes() {
   const themes = new Set(Object.keys(getBuiltinThemes()));
   const customThemesDir = getCustomThemesDir();
-  if (fs11.existsSync(customThemesDir)) {
-    const files = fs11.readdirSync(customThemesDir);
+  if (fs12.existsSync(customThemesDir)) {
+    const files = fs12.readdirSync(customThemesDir);
     for (const file of files) {
       if (file.endsWith(".json")) {
         themes.add(file.slice(0, -5));
@@ -56120,18 +56768,18 @@ function loadThemeJson(name) {
   }
   const registeredTheme = registeredThemes.get(name);
   if (registeredTheme?.sourcePath) {
-    const content2 = fs11.readFileSync(registeredTheme.sourcePath, "utf-8");
+    const content2 = fs12.readFileSync(registeredTheme.sourcePath, "utf-8");
     return parseThemeJsonContent(registeredTheme.sourcePath, content2);
   }
   if (registeredTheme) {
     throw new Error(`Theme "${name}" does not have a source path for export`);
   }
   const customThemesDir = getCustomThemesDir();
-  const themePath = path10.join(customThemesDir, `${name}.json`);
-  if (!fs11.existsSync(themePath)) {
+  const themePath = path11.join(customThemesDir, `${name}.json`);
+  if (!fs12.existsSync(themePath)) {
     throw new Error(`Theme not found: ${name}`);
   }
-  const content = fs11.readFileSync(themePath, "utf-8");
+  const content = fs12.readFileSync(themePath, "utf-8");
   return parseThemeJsonContent(name, content);
 }
 function createTheme(themeJson, mode, sourcePath) {
@@ -56244,12 +56892,12 @@ function startThemeWatcher() {
     return;
   }
   const customThemesDir = getCustomThemesDir();
-  const themeFile = path10.join(customThemesDir, `${currentThemeName}.json`);
-  if (!fs11.existsSync(themeFile)) {
+  const themeFile = path11.join(customThemesDir, `${currentThemeName}.json`);
+  if (!fs12.existsSync(themeFile)) {
     return;
   }
   try {
-    themeWatcher = fs11.watch(themeFile, (eventType) => {
+    themeWatcher = fs12.watch(themeFile, (eventType) => {
       if (eventType === "change") {
         setTimeout(() => {
           try {
@@ -56262,7 +56910,7 @@ function startThemeWatcher() {
         }, 100);
       } else if (eventType === "rename") {
         setTimeout(() => {
-          if (!fs11.existsSync(themeFile)) {
+          if (!fs12.existsSync(themeFile)) {
             currentThemeName = "dark";
             setGlobalTheme(loadTheme("dark"));
             if (themeWatcher) {
@@ -56442,8 +57090,9 @@ function getSettingsListTheme() {
 }
 
 // src/skills/loader.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
+import * as fs13 from "fs";
+import * as os4 from "os";
+import * as path12 from "path";
 function parseSkillDescription(content) {
   const frontmatterMatch = content.match(/^---\n[\s\S]*?description:\s*["']?(.+?)["']?(?:\n|$)/m);
   if (frontmatterMatch) return frontmatterMatch[1].trim();
@@ -56458,21 +57107,53 @@ function parseSkillDescription(content) {
   }
   return "No description";
 }
+var USER_CONTROLLED_SOURCES = /* @__PURE__ */ new Set(["user-agents", "user"]);
+function pathIsInside(child, parent) {
+  const relative3 = path12.relative(parent, child);
+  return relative3 !== "" && !relative3.startsWith(`..${path12.sep}`) && relative3 !== ".." && !path12.isAbsolute(relative3);
+}
+function resolveSkillSymlink(fullPath, dir, source) {
+  let target;
+  let stats;
+  try {
+    target = fs13.realpathSync(fullPath);
+    stats = fs13.statSync(target);
+  } catch {
+    return { error: `broken skill symlink: ${fullPath}` };
+  }
+  if (!USER_CONTROLLED_SOURCES.has(source) && !pathIsInside(target, fs13.realpathSync(dir))) {
+    return { error: `skill symlink escapes the "${source}" layer (not loaded): ${fullPath} -> ${target}` };
+  }
+  return { target, isDirectory: stats.isDirectory(), isFile: stats.isFile() };
+}
 function loadSkillsFromDir(dir, source) {
   const skills = [];
   const diagnostics = [];
-  if (!fs12.existsSync(dir)) {
+  if (!fs13.existsSync(dir)) {
     return { skills, diagnostics };
   }
-  const entries = fs12.readdirSync(dir, { withFileTypes: true });
+  const entries = fs13.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const fullPath = path11.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const skillMdPath = path11.join(fullPath, "SKILL.md");
-      if (fs12.existsSync(skillMdPath)) {
+    const fullPath = path12.join(dir, entry.name);
+    let entryPath = fullPath;
+    let entryIsDirectory = entry.isDirectory();
+    let entryIsFile = entry.isFile();
+    if (entry.isSymbolicLink()) {
+      const resolved = resolveSkillSymlink(fullPath, dir, source);
+      if ("error" in resolved) {
+        diagnostics.push({ type: "warning", message: resolved.error, path: fullPath });
+        continue;
+      }
+      entryPath = resolved.target;
+      entryIsDirectory = resolved.isDirectory;
+      entryIsFile = resolved.isFile;
+    }
+    if (entryIsDirectory) {
+      const skillMdPath = path12.join(entryPath, "SKILL.md");
+      if (fs13.existsSync(skillMdPath)) {
         try {
-          const content = fs12.readFileSync(skillMdPath, "utf-8");
+          const content = fs13.readFileSync(skillMdPath, "utf-8");
           const description = parseSkillDescription(content);
           skills.push({
             name: entry.name,
@@ -56480,7 +57161,7 @@ function loadSkillsFromDir(dir, source) {
             content,
             filePath: skillMdPath,
             source,
-            baseDir: fullPath
+            baseDir: entryPath
           });
         } catch (e) {
           diagnostics.push({
@@ -56490,64 +57171,72 @@ function loadSkillsFromDir(dir, source) {
           });
         }
       }
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+    } else if (entryIsFile && entry.name.endsWith(".md")) {
       const name = entry.name.slice(0, -3);
       try {
-        const content = fs12.readFileSync(fullPath, "utf-8");
+        const content = fs13.readFileSync(entryPath, "utf-8");
         const description = parseSkillDescription(content);
         skills.push({
           name,
           description,
           content,
-          filePath: fullPath,
+          filePath: entryPath,
           source,
-          baseDir: dir
+          baseDir: path12.dirname(entryPath)
         });
       } catch (e) {
         diagnostics.push({
           type: "warning",
           message: `Failed to load skill: ${name}`,
-          path: fullPath
+          path: entryPath
         });
       }
     }
   }
   return { skills, diagnostics };
 }
+function discoverAgentsSkillsDirs(cwd) {
+  const resolvedCwd = path12.resolve(cwd || process.cwd());
+  const projectRoot = resolveCliProjectRoot(resolvedCwd);
+  const projectAgentsDirs = [];
+  let current = projectRoot;
+  while (true) {
+    projectAgentsDirs.push(path12.join(current, ".agents", "skills"));
+    if (current === resolvedCwd) break;
+    const child = path12.relative(current, resolvedCwd).split(path12.sep)[0];
+    if (!child) break;
+    current = path12.join(current, child);
+  }
+  return { userAgentsDir: path12.join(os4.homedir(), ".agents", "skills"), projectAgentsDirs };
+}
+function buildSkillDirs(options) {
+  const { userAgentsDir, projectAgentsDirs } = discoverAgentsSkillsDirs(options.cwd);
+  return [
+    { dir: options.builtinDir, source: "builtin" },
+    { dir: userAgentsDir, source: "user-agents" },
+    { dir: options.userDir, source: "user" },
+    ...projectAgentsDirs.map((dir) => ({ dir, source: "project-agents" })),
+    { dir: options.projectDir, source: "project" }
+  ];
+}
 function loadSkills(options) {
-  const { builtinDir, userDir, projectDir } = options;
   const skillMap = /* @__PURE__ */ new Map();
   const diagnostics = [];
-  const builtinResult = loadSkillsFromDir(builtinDir, "builtin");
-  for (const skill of builtinResult.skills) {
-    skillMap.set(skill.name, skill);
-  }
-  diagnostics.push(...builtinResult.diagnostics);
-  const userResult = loadSkillsFromDir(userDir, "user");
-  for (const skill of userResult.skills) {
-    if (skillMap.has(skill.name)) {
-      diagnostics.push({
-        type: "collision",
-        message: `Skill "${skill.name}" collision: user skill overrides builtin`,
-        path: skill.filePath
-      });
-    }
-    skillMap.set(skill.name, skill);
-  }
-  diagnostics.push(...userResult.diagnostics);
-  const projectResult = loadSkillsFromDir(projectDir, "project");
-  for (const skill of projectResult.skills) {
-    if (skillMap.has(skill.name)) {
+  for (const { dir, source } of options.dirs) {
+    const result = loadSkillsFromDir(dir, source);
+    for (const skill of result.skills) {
       const existing = skillMap.get(skill.name);
-      diagnostics.push({
-        type: "collision",
-        message: `Skill "${skill.name}" collision: project skill overrides ${existing.source}`,
-        path: skill.filePath
-      });
+      if (existing) {
+        diagnostics.push({
+          type: "collision",
+          message: `Skill "${skill.name}" collision: ${source} skill overrides ${existing.source}`,
+          path: skill.filePath
+        });
+      }
+      skillMap.set(skill.name, skill);
     }
-    skillMap.set(skill.name, skill);
+    diagnostics.push(...result.diagnostics);
   }
-  diagnostics.push(...projectResult.diagnostics);
   return { skills: Array.from(skillMap.values()), diagnostics };
 }
 function formatSkillsForPrompt(skills) {
@@ -56688,9 +57377,12 @@ function validateSkillName(name) {
   return { valid: true };
 }
 
+// src/interactive-mode.ts
+import * as path29 from "path";
+
 // src/capabilities/read-file-understanding.ts
-import * as path20 from "node:path";
-import * as fs20 from "node:fs/promises";
+import * as path21 from "node:path";
+import * as fs21 from "node:fs/promises";
 
 // src/core/provider-capabilities.ts
 var PLATFORM_DISPLAY_NAMES = {
@@ -56716,8 +57408,8 @@ function getProviderDisplayName(platform2) {
 }
 
 // src/files/adapters/kimi-adapter.ts
-import * as fs13 from "node:fs";
-import * as path12 from "node:path";
+import * as fs14 from "node:fs";
+import * as path13 from "node:path";
 
 // src/files/errors.ts
 var FileErrorMessages = {
@@ -56854,17 +57546,17 @@ var KimiFileAdapter = class {
   // Upload
   // ============================================================================
   async upload(filePath, options = {}) {
-    const fileName = options.sourceName || path12.basename(filePath);
+    const fileName = options.sourceName || path13.basename(filePath);
     const mimeType = options.mimeType || this.guessMimeType(fileName);
     const purpose = this.detectPurpose(filePath, options.purpose, mimeType);
-    const stats = fs13.statSync(filePath);
+    const stats = fs14.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
         `File size ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds Kimi limit of 100MB`
       );
     }
-    const fileBuffer = fs13.readFileSync(filePath);
+    const fileBuffer = fs14.readFileSync(filePath);
     const file = new File([fileBuffer], fileName, { type: mimeType });
     const formData = new FormData();
     formData.append("file", file);
@@ -56916,7 +57608,7 @@ var KimiFileAdapter = class {
     return "file-extract";
   }
   guessMimeType(filename) {
-    const ext = path12.extname(filename).toLowerCase();
+    const ext = path13.extname(filename).toLowerCase();
     switch (ext) {
       case ".jpg":
       case ".jpeg":
@@ -57078,8 +57770,8 @@ var KimiFileAdapter = class {
 };
 
 // src/files/adapters/gemini-adapter.ts
-import * as fs14 from "node:fs";
-import * as path13 from "node:path";
+import * as fs15 from "node:fs";
+import * as path14 from "node:path";
 import { Readable } from "node:stream";
 var GeminiFileAdapter = class {
   platform = "gemini";
@@ -57136,7 +57828,7 @@ var GeminiFileAdapter = class {
   // Upload
   // ============================================================================
   async upload(filePath, options = {}) {
-    const stats = fs14.statSync(filePath);
+    const stats = fs15.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
@@ -57144,7 +57836,7 @@ var GeminiFileAdapter = class {
       );
     }
     const mimeType = options.mimeType || this.guessMimeType(filePath);
-    const displayName = options.sourceName || path13.basename(filePath);
+    const displayName = options.sourceName || path14.basename(filePath);
     const startResponse = await fetch(
       `${this.baseUrl}/upload/v1beta/files?key=${this.apiKey}`,
       {
@@ -57175,7 +57867,7 @@ var GeminiFileAdapter = class {
         "No upload URL received"
       );
     }
-    const fileStream = Readable.toWeb(fs14.createReadStream(filePath));
+    const fileStream = Readable.toWeb(fs15.createReadStream(filePath));
     const uploadResponse = await fetch(uploadUrl, {
       method: "POST",
       headers: {
@@ -57379,8 +58071,8 @@ var GeminiFileAdapter = class {
 };
 
 // src/files/adapters/openai-compatible-files-adapter.ts
-import * as fs15 from "node:fs";
-import * as path14 from "node:path";
+import * as fs16 from "node:fs";
+import * as path15 from "node:path";
 var OpenAICompatibleFilesAdapter = class {
   constructor(apiKey, baseUrl, extraHeaders = {}) {
     this.apiKey = apiKey;
@@ -57406,16 +58098,16 @@ var OpenAICompatibleFilesAdapter = class {
     ]
   };
   async upload(filePath, options = {}) {
-    const fileName = options.sourceName || path14.basename(filePath);
+    const fileName = options.sourceName || path15.basename(filePath);
     const mimeType = options.mimeType || guessMimeType(fileName);
-    const stats = fs15.statSync(filePath);
+    const stats = fs16.statSync(filePath);
     if (stats.size > this.capabilities.maxFileSize) {
       throw new FileManagerError(
         "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
         `File size ${(stats.size / 1024 / 1024).toFixed(1)}MB exceeds OpenAI-compatible Files limit of ${this.capabilities.maxFileSize / 1024 / 1024}MB`
       );
     }
-    const file = new File([fs15.readFileSync(filePath)], fileName, { type: mimeType });
+    const file = new File([fs16.readFileSync(filePath)], fileName, { type: mimeType });
     const formData = new FormData();
     formData.append("file", file);
     formData.append("purpose", options.purpose && options.purpose !== "auto" ? options.purpose : "file-extract");
@@ -57532,7 +58224,7 @@ function extractContentText(raw) {
   return raw;
 }
 function guessMimeType(filename) {
-  const ext = path14.extname(filename).toLowerCase();
+  const ext = path15.extname(filename).toLowerCase();
   switch (ext) {
     case ".pdf":
       return "application/pdf";
@@ -57548,13 +58240,13 @@ function guessMimeType(filename) {
 }
 
 // src/files/file-manager.ts
-import * as fs19 from "node:fs";
-import * as path19 from "node:path";
+import * as fs20 from "node:fs";
+import * as path20 from "node:path";
 import * as crypto2 from "node:crypto";
 
 // src/files/file-cache.ts
-import * as fs16 from "node:fs";
-import * as path16 from "node:path";
+import * as fs17 from "node:fs";
+import * as path17 from "node:path";
 import * as crypto from "node:crypto";
 
 // src/files/logger.ts
@@ -57649,14 +58341,14 @@ var DEFAULT_PIC_OPTIONS = {
 };
 
 // src/files/utils.ts
-import * as path15 from "node:path";
-import { homedir as homedir4 } from "node:os";
+import * as path16 from "node:path";
+import { homedir as homedir5 } from "node:os";
 var WINDOWS_ABSOLUTE_PATH_RE = /^(?:[a-zA-Z]:[\\/]|[\\/]{2}[^\\/]+[\\/][^\\/]+)/;
 function isWindowsAbsolutePath(filePath) {
   return WINDOWS_ABSOLUTE_PATH_RE.test(filePath);
 }
 function getHomeDirectory() {
-  return homedir4() || process.env.USERPROFILE || process.env.HOME || ".";
+  return homedir5() || process.env.USERPROFILE || process.env.HOME || ".";
 }
 function looksLikeFilePath(inputPath) {
   return inputPath.startsWith("/") || inputPath.startsWith("~") || inputPath.startsWith("./") || inputPath.startsWith("../") || inputPath.startsWith(".\\") || inputPath.startsWith("..\\") || isWindowsAbsolutePath(inputPath);
@@ -57670,13 +58362,13 @@ function formatBytes(bytes) {
 }
 function resolvePath2(inputPath) {
   if (inputPath.startsWith("~")) {
-    return path15.join(getHomeDirectory(), inputPath.slice(1));
+    return path16.join(getHomeDirectory(), inputPath.slice(1));
   }
   if (isWindowsAbsolutePath(inputPath)) {
     return inputPath;
   }
-  if (!path15.isAbsolute(inputPath)) {
-    return path15.resolve(process.cwd(), inputPath);
+  if (!path16.isAbsolute(inputPath)) {
+    return path16.resolve(process.cwd(), inputPath);
   }
   return inputPath;
 }
@@ -57704,8 +58396,8 @@ var FileCache = class _FileCache {
   maxEntries;
   constructor(baseDir, maxEntries = DEFAULT_MAX_CACHE_ENTRIES) {
     this.baseDir = baseDir;
-    this.dataDir = path16.join(baseDir, "data");
-    this.indexPath = path16.join(baseDir, "index.json");
+    this.dataDir = path17.join(baseDir, "data");
+    this.indexPath = path17.join(baseDir, "index.json");
     this.maxEntries = maxEntries;
     this.index = this.loadIndex();
     this.ensureDirectories();
@@ -57714,22 +58406,22 @@ var FileCache = class _FileCache {
   // Directory Management
   // ============================================================================
   ensureDirectories() {
-    if (!fs16.existsSync(this.baseDir)) {
-      fs16.mkdirSync(this.baseDir, { recursive: true });
+    if (!fs17.existsSync(this.baseDir)) {
+      fs17.mkdirSync(this.baseDir, { recursive: true });
     }
-    if (!fs16.existsSync(this.dataDir)) {
-      fs16.mkdirSync(this.dataDir, { recursive: true });
+    if (!fs17.existsSync(this.dataDir)) {
+      fs17.mkdirSync(this.dataDir, { recursive: true });
     }
   }
   // ============================================================================
   // Index Management
   // ============================================================================
   loadIndex() {
-    if (!fs16.existsSync(this.indexPath)) {
+    if (!fs17.existsSync(this.indexPath)) {
       return { version: CACHE_VERSION, files: {}, pathHints: {} };
     }
     try {
-      const data = JSON.parse(fs16.readFileSync(this.indexPath, "utf-8"));
+      const data = JSON.parse(fs17.readFileSync(this.indexPath, "utf-8"));
       if (data.version !== CACHE_VERSION) {
         cacheLogger.warn(`Index version mismatch: ${data.version} vs ${CACHE_VERSION}`);
       }
@@ -57745,7 +58437,7 @@ var FileCache = class _FileCache {
   }
   saveIndex() {
     try {
-      fs16.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+      fs17.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
     } catch (err) {
       cacheLogger.error(" Failed to save index:", err);
       throw err;
@@ -57755,11 +58447,11 @@ var FileCache = class _FileCache {
   // Hash Computation
   // ============================================================================
   async computeHash(filePath) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const hash = crypto.createHash("sha256");
-      const stream = fs16.createReadStream(filePath);
+      const stream = fs17.createReadStream(filePath);
       stream.on("data", (chunk) => hash.update(chunk));
-      stream.on("end", () => resolve6(hash.digest("hex")));
+      stream.on("end", () => resolve7(hash.digest("hex")));
       stream.on("error", reject);
     });
   }
@@ -57771,25 +58463,25 @@ var FileCache = class _FileCache {
   // ============================================================================
   getStoragePath(hash) {
     const subdir = hash.slice(0, 2);
-    const fullDir = path16.join(this.dataDir, subdir);
-    if (!fs16.existsSync(fullDir)) {
-      fs16.mkdirSync(fullDir, { recursive: true });
+    const fullDir = path17.join(this.dataDir, subdir);
+    if (!fs17.existsSync(fullDir)) {
+      fs17.mkdirSync(fullDir, { recursive: true });
     }
-    return path16.join(fullDir, hash);
+    return path17.join(fullDir, hash);
   }
   getStorageRelativePath(hash) {
     const subdir = hash.slice(0, 2);
-    return path16.join(subdir, hash);
+    return path17.join(subdir, hash);
   }
   async storeFile(sourcePath, name, mimeType) {
     const hash = await this.computeHash(sourcePath);
     const storagePath = this.getStoragePath(hash);
     this.rememberPathHint(sourcePath, hash, name);
-    if (fs16.existsSync(storagePath)) {
+    if (fs17.existsSync(storagePath)) {
       return { hash, localPath: storagePath };
     }
-    fs16.copyFileSync(sourcePath, storagePath);
-    const stat2 = fs16.statSync(storagePath);
+    fs17.copyFileSync(sourcePath, storagePath);
+    const stat2 = fs17.statSync(storagePath);
     this.index.files[hash] = {
       hash,
       name,
@@ -57806,10 +58498,10 @@ var FileCache = class _FileCache {
   async storeBuffer(data, name, mimeType) {
     const hash = this.computeHashSync(data);
     const storagePath = this.getStoragePath(hash);
-    if (fs16.existsSync(storagePath)) {
+    if (fs17.existsSync(storagePath)) {
       return { hash, localPath: storagePath };
     }
-    fs16.writeFileSync(storagePath, data);
+    fs17.writeFileSync(storagePath, data);
     this.index.files[hash] = {
       hash,
       name,
@@ -57841,7 +58533,7 @@ var FileCache = class _FileCache {
   getLocalPath(hash) {
     const entry = this.index.files[hash];
     if (!entry) return void 0;
-    return path16.join(this.dataDir, entry.localPath);
+    return path17.join(this.dataDir, entry.localPath);
   }
   exists(hash) {
     return hash in this.index.files;
@@ -57881,7 +58573,7 @@ var FileCache = class _FileCache {
   getPathHint(filePath) {
     try {
       const resolvedPath = this.getResolvedHintPath(filePath);
-      const stat2 = fs16.statSync(resolvedPath);
+      const stat2 = fs17.statSync(resolvedPath);
       if (!stat2.isFile()) return void 0;
       const normalizedMtimeMs = this.normalizeHintMtimeMs(stat2.mtimeMs);
       const key = this.getPathHintKey(resolvedPath);
@@ -57911,7 +58603,7 @@ var FileCache = class _FileCache {
   rememberPathHint(filePath, hash, name) {
     try {
       const resolvedPath = this.getResolvedHintPath(filePath);
-      const stat2 = fs16.statSync(resolvedPath);
+      const stat2 = fs17.statSync(resolvedPath);
       if (!stat2.isFile()) return;
       const entry = this.index.files[hash];
       const normalizedMtimeMs = this.normalizeHintMtimeMs(stat2.mtimeMs);
@@ -57921,7 +58613,7 @@ var FileCache = class _FileCache {
       this.index.pathHints[this.getPathHintKey(resolvedPath)] = {
         path: resolvedPath,
         hash,
-        name: name || entry?.name || path16.basename(resolvedPath),
+        name: name || entry?.name || path17.basename(resolvedPath),
         size: stat2.size,
         mtimeMs: normalizedMtimeMs,
         lastSeenAt: Date.now(),
@@ -57969,9 +58661,9 @@ var FileCache = class _FileCache {
   deleteEntry(hash, entry) {
     entry = entry || this.index.files[hash];
     if (!entry) return;
-    const localPath = path16.join(this.dataDir, entry.localPath);
-    if (fs16.existsSync(localPath)) {
-      fs16.unlinkSync(localPath);
+    const localPath = path17.join(this.dataDir, entry.localPath);
+    if (fs17.existsSync(localPath)) {
+      fs17.unlinkSync(localPath);
     }
     delete this.index.files[hash];
     if (this.index.pathHints) {
@@ -57985,9 +58677,9 @@ var FileCache = class _FileCache {
   }
   clear() {
     for (const entry of Object.values(this.index.files)) {
-      const localPath = path16.join(this.dataDir, entry.localPath);
-      if (fs16.existsSync(localPath)) {
-        fs16.unlinkSync(localPath);
+      const localPath = path17.join(this.dataDir, entry.localPath);
+      if (fs17.existsSync(localPath)) {
+        fs17.unlinkSync(localPath);
       }
     }
     this.index = { version: CACHE_VERSION, files: {}, pathHints: {} };
@@ -58040,11 +58732,11 @@ var FileCache = class _FileCache {
     };
   }
   static getMimeType(fileName) {
-    const ext = path16.extname(fileName).toLowerCase();
+    const ext = path17.extname(fileName).toLowerCase();
     return MIME_TYPES[ext] || "application/octet-stream";
   }
   static getFileTypeFromName(fileName) {
-    const baseName = path16.basename(fileName);
+    const baseName = path17.basename(fileName);
     if (!baseName || baseName.startsWith(".")) {
       return void 0;
     }
@@ -58075,7 +58767,7 @@ var FileCache = class _FileCache {
   getResolvedHintPath(filePath) {
     const resolvedPath = resolvePath2(filePath);
     try {
-      return fs16.realpathSync.native ? fs16.realpathSync.native(resolvedPath) : fs16.realpathSync(resolvedPath);
+      return fs17.realpathSync.native ? fs17.realpathSync.native(resolvedPath) : fs17.realpathSync(resolvedPath);
     } catch {
       return resolvedPath;
     }
@@ -58083,8 +58775,8 @@ var FileCache = class _FileCache {
 };
 
 // src/files/session-file-manager.ts
-import * as fs17 from "node:fs";
-import * as path17 from "node:path";
+import * as fs18 from "node:fs";
+import * as path18 from "node:path";
 var INITIAL_REFRESH_BACKOFF_MS = 6e4;
 var MAX_REFRESH_BACKOFF_MS = 60 * 60 * 1e3;
 var SessionFileManager = class {
@@ -58098,7 +58790,7 @@ var SessionFileManager = class {
   constructor(sessionId, sessionsDir, fileCache, authFingerprint) {
     this.sessionId = sessionId;
     this.sessionsDir = sessionsDir;
-    this.statePath = path17.join(this.sessionsDir, `${sessionId}-files.json`);
+    this.statePath = path18.join(this.sessionsDir, `${sessionId}-files.json`);
     this.fileCache = fileCache;
     this.authFingerprint = authFingerprint;
     this.state = this.loadState();
@@ -58108,15 +58800,15 @@ var SessionFileManager = class {
   // Directory Management
   // ============================================================================
   ensureDirectories() {
-    if (!fs17.existsSync(this.sessionsDir)) {
-      fs17.mkdirSync(this.sessionsDir, { recursive: true });
+    if (!fs18.existsSync(this.sessionsDir)) {
+      fs18.mkdirSync(this.sessionsDir, { recursive: true });
     }
   }
   // ============================================================================
   // State Management
   // ============================================================================
   loadState() {
-    if (!fs17.existsSync(this.statePath)) {
+    if (!fs18.existsSync(this.statePath)) {
       return {
         sessionId: this.sessionId,
         lastSyncedAt: 0,
@@ -58124,7 +58816,7 @@ var SessionFileManager = class {
       };
     }
     try {
-      return JSON.parse(fs17.readFileSync(this.statePath, "utf-8"));
+      return JSON.parse(fs18.readFileSync(this.statePath, "utf-8"));
     } catch (err) {
       sessionLogger.error(" Failed to load state:", err);
       return {
@@ -58137,12 +58829,12 @@ var SessionFileManager = class {
   saveState() {
     try {
       if (Object.keys(this.state.files).length === 0) {
-        if (fs17.existsSync(this.statePath)) {
-          fs17.unlinkSync(this.statePath);
+        if (fs18.existsSync(this.statePath)) {
+          fs18.unlinkSync(this.statePath);
         }
         return;
       }
-      fs17.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
+      fs18.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2));
     } catch (err) {
       sessionLogger.error(" Failed to save state:", err);
     }
@@ -58288,7 +58980,7 @@ var SessionFileManager = class {
       return { success: false, coolingDown: true };
     }
     const localPath = this.fileCache.getLocalPath(entry.hash);
-    if (!localPath || !fs17.existsSync(localPath)) {
+    if (!localPath || !fs18.existsSync(localPath)) {
       sessionLogger.warn(`Local file not found for ${fileId}`);
       entry.status = "expired";
       entry.error = "Local file missing";
@@ -58439,15 +59131,15 @@ var SessionFileManager = class {
   // Static Utilities
   // ============================================================================
   static cleanupOldSessions(sessionsDir, maxAge = 30 * 24 * 60 * 60 * 1e3) {
-    if (!fs17.existsSync(sessionsDir)) return;
+    if (!fs18.existsSync(sessionsDir)) return;
     const now = Date.now();
-    const files = fs17.readdirSync(sessionsDir);
+    const files = fs18.readdirSync(sessionsDir);
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
-      const filePath = path17.join(sessionsDir, file);
-      const stat2 = fs17.statSync(filePath);
+      const filePath = path18.join(sessionsDir, file);
+      const stat2 = fs18.statSync(filePath);
       if (now - stat2.mtime.getTime() > maxAge) {
-        fs17.unlinkSync(filePath);
+        fs18.unlinkSync(filePath);
         sessionLogger.debug(`Cleaned up old session: ${file}`);
       }
     }
@@ -58455,8 +59147,8 @@ var SessionFileManager = class {
 };
 
 // src/files/ffmpeg-processor.ts
-import * as fs18 from "node:fs";
-import * as path18 from "node:path";
+import * as fs19 from "node:fs";
+import * as path19 from "node:path";
 import { spawn } from "node:child_process";
 var FFmpegProcessor = class {
   ffmpegPath = "ffmpeg";
@@ -58469,17 +59161,17 @@ var FFmpegProcessor = class {
   // Detection
   // ============================================================================
   async checkAvailability() {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const proc = spawn(this.ffmpegPath, ["-version"]);
-      proc.on("error", () => resolve6(false));
-      proc.on("exit", (code) => resolve6(code === 0));
+      proc.on("error", () => resolve7(false));
+      proc.on("exit", (code) => resolve7(code === 0));
     });
   }
   // ============================================================================
   // Video Analysis
   // ============================================================================
   async analyzeVideo(videoPath) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const args = [
         "-v",
         "error",
@@ -58508,7 +59200,7 @@ var FFmpegProcessor = class {
         }
         try {
           const info = this.parseProbeOutput(stdout, videoPath);
-          resolve6(info);
+          resolve7(info);
         } catch (err) {
           reject(err);
         }
@@ -58560,7 +59252,7 @@ var FFmpegProcessor = class {
   }
   async compressVideo(inputPath, outputDir, info, opts, onProgress) {
     const outputName = `compressed_${Date.now()}.mp4`;
-    const outputPath = path18.join(outputDir, outputName);
+    const outputPath = path19.join(outputDir, outputName);
     const adaptiveParams = this.calculateAdaptiveParams(info.duration, opts);
     const args = [
       "-i",
@@ -58591,7 +59283,7 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    const outputStat = fs18.statSync(outputPath);
+    const outputStat = fs19.statSync(outputPath);
     return {
       type: "video",
       output: outputPath,
@@ -58622,9 +59314,9 @@ var FFmpegProcessor = class {
   }
   async extractKeyframes(inputPath, outputDir, info, opts, onProgress) {
     const interval = Math.floor(info.duration / opts.keyframeCount);
-    const framesDir = path18.join(outputDir, `keyframes_${Date.now()}`);
-    fs18.mkdirSync(framesDir, { recursive: true });
-    const outputPattern = path18.join(framesDir, "frame_%03d.jpg");
+    const framesDir = path19.join(outputDir, `keyframes_${Date.now()}`);
+    fs19.mkdirSync(framesDir, { recursive: true });
+    const outputPattern = path19.join(framesDir, "frame_%03d.jpg");
     const args = [
       "-i",
       inputPath,
@@ -58642,10 +59334,10 @@ var FFmpegProcessor = class {
         onProgress?.(percent);
       }
     });
-    let frames = fs18.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path18.join(framesDir, f));
+    let frames = fs19.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path19.join(framesDir, f));
     if (frames.length < opts.keyframeCount / 2) {
-      fs18.rmSync(framesDir, { recursive: true, force: true });
-      fs18.mkdirSync(framesDir, { recursive: true });
+      fs19.rmSync(framesDir, { recursive: true, force: true });
+      fs19.mkdirSync(framesDir, { recursive: true });
       const uniformArgs = [
         "-i",
         inputPath,
@@ -58661,10 +59353,10 @@ var FFmpegProcessor = class {
           onProgress?.(percent);
         }
       });
-      frames = fs18.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path18.join(framesDir, f));
+      frames = fs19.readdirSync(framesDir).filter((f) => f.endsWith(".jpg")).sort().map((f) => path19.join(framesDir, f));
     }
     const totalOutputSize = frames.reduce(
-      (sum, f) => sum + fs18.statSync(f).size,
+      (sum, f) => sum + fs19.statSync(f).size,
       0
     );
     return {
@@ -58685,7 +59377,7 @@ var FFmpegProcessor = class {
     const opts = { ...DEFAULT_PIC_OPTIONS, ...options };
     const ext = opts.format === "webp" ? ".webp" : ".jpg";
     const outputName = `optimized_${Date.now()}${ext}`;
-    const outputPath = path18.join(outputDir, outputName);
+    const outputPath = path19.join(outputDir, outputName);
     const args = [
       "-i",
       inputPath,
@@ -58703,7 +59395,7 @@ var FFmpegProcessor = class {
   // FFmpeg Execution
   // ============================================================================
   runFFmpeg(args) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const proc = spawn(this.ffmpegPath, args);
       let stderr = "";
       proc.stderr.on("data", (data) => {
@@ -58718,7 +59410,7 @@ var FFmpegProcessor = class {
             )
           );
         } else {
-          resolve6();
+          resolve7();
         }
       });
       proc.on("error", (err) => {
@@ -58735,7 +59427,7 @@ var FFmpegProcessor = class {
   // Progress Monitoring (for future use)
   // ============================================================================
   async runWithProgress(args, onProgress) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const progressArgs = [
         ...args,
         "-progress",
@@ -58765,7 +59457,7 @@ var FFmpegProcessor = class {
             )
           );
         } else {
-          resolve6();
+          resolve7();
         }
       });
     });
@@ -58860,8 +59552,8 @@ var DIRECTORY_LISTING_TTL_MS = 1500;
 var FileManager = class {
   constructor(options) {
     this.options = options;
-    const baseDir = options.baseDir || path19.join(process.env.HOME || ".", ".pie", "files");
-    const sessionsDir = options.sessionsDir || path19.join(process.env.HOME || ".", ".pie", "sessions");
+    const baseDir = options.baseDir || path20.join(process.env.HOME || ".", ".pie", "files");
+    const sessionsDir = options.sessionsDir || path20.join(process.env.HOME || ".", ".pie", "sessions");
     this.fileCache = new FileCache(baseDir);
     this.authFingerprint = options.apiKey ? this.buildAuthFingerprint(options.apiKey) : void 0;
     this.sessionManager = new SessionFileManager(
@@ -58872,7 +59564,7 @@ var FileManager = class {
     );
     this.ffmpeg = new FFmpegProcessor(options.ffmpegPath);
     this.platform = normalizeFileManagerPlatform(options.platform);
-    this.tempDir = path19.join(baseDir, "temp");
+    this.tempDir = path20.join(baseDir, "temp");
     this.ensureDirectories();
   }
   options;
@@ -58884,8 +59576,8 @@ var FileManager = class {
   directoryListingCache = /* @__PURE__ */ new Map();
   authFingerprint;
   ensureDirectories() {
-    if (!fs19.existsSync(this.tempDir)) {
-      fs19.mkdirSync(this.tempDir, { recursive: true });
+    if (!fs20.existsSync(this.tempDir)) {
+      fs20.mkdirSync(this.tempDir, { recursive: true });
     }
   }
   // ============================================================================
@@ -58915,8 +59607,8 @@ var FileManager = class {
   // ============================================================================
   async stageLocal(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    const sourceName = options.sourceName || path19.basename(resolvedPath);
-    if (!fs19.existsSync(resolvedPath)) {
+    const sourceName = options.sourceName || path20.basename(resolvedPath);
+    if (!fs20.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -58931,7 +59623,7 @@ var FileManager = class {
     this.fileCache.rememberPathHint(resolvedPath, hash, sourceName);
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     const entry = this.fileCache.getByHash(hash);
-    const size = entry?.size ?? fs19.statSync(resolvedPath).size;
+    const size = entry?.size ?? fs20.statSync(resolvedPath).size;
     return {
       success: true,
       hash,
@@ -58945,8 +59637,8 @@ var FileManager = class {
   }
   async upload(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    const sourceName = options.sourceName || path19.basename(resolvedPath);
-    if (!fs19.existsSync(resolvedPath)) {
+    const sourceName = options.sourceName || path20.basename(resolvedPath);
+    if (!fs20.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -59027,7 +59719,7 @@ var FileManager = class {
   // ============================================================================
   async uploadPic(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    if (!fs19.existsSync(resolvedPath)) {
+    if (!fs20.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -59035,7 +59727,7 @@ var FileManager = class {
     }
     const cachedResult = await this.tryReuseCachedSourceUpload(
       resolvedPath,
-      options.sourceName || path19.basename(resolvedPath),
+      options.sourceName || path20.basename(resolvedPath),
       options.platform || this.platform
     );
     if (cachedResult) {
@@ -59052,12 +59744,12 @@ var FileManager = class {
     const result = await this.upload(optimizedPath, {
       ...options,
       purpose: "image",
-      sourceName: path19.basename(resolvedPath)
+      sourceName: path20.basename(resolvedPath)
     });
-    this.fileCache.rememberPathHint(resolvedPath, result.hash, path19.basename(resolvedPath));
+    this.fileCache.rememberPathHint(resolvedPath, result.hash, path20.basename(resolvedPath));
     this.invalidateDirectoryListingCacheForPath(resolvedPath);
     try {
-      fs19.unlinkSync(optimizedPath);
+      fs20.unlinkSync(optimizedPath);
     } catch {
     }
     return result;
@@ -59067,7 +59759,7 @@ var FileManager = class {
   // ============================================================================
   async uploadVideo(filePath, options = {}) {
     const resolvedPath = resolvePath2(filePath);
-    if (!fs19.existsSync(resolvedPath)) {
+    if (!fs20.existsSync(resolvedPath)) {
       throw new FileManagerError(
         "LOCAL_FILE_MISSING" /* LOCAL_FILE_MISSING */,
         `File not found: ${filePath}`
@@ -59075,7 +59767,7 @@ var FileManager = class {
     }
     const cachedResult = await this.tryReuseCachedSourceUpload(
       resolvedPath,
-      options.sourceName || path19.basename(resolvedPath),
+      options.sourceName || path20.basename(resolvedPath),
       options.platform || this.platform
     );
     if (cachedResult) {
@@ -59125,9 +59817,9 @@ var FileManager = class {
       result = await this.upload(preprocessResult.output, {
         ...options,
         purpose: "video",
-        sourceName: path19.basename(resolvedPath)
+        sourceName: path20.basename(resolvedPath)
       });
-      this.fileCache.rememberPathHint(resolvedPath, result.hash, path19.basename(resolvedPath));
+      this.fileCache.rememberPathHint(resolvedPath, result.hash, path20.basename(resolvedPath));
       this.invalidateDirectoryListingCacheForPath(resolvedPath);
     } else {
       throw new FileManagerError(
@@ -59419,7 +60111,7 @@ var FileManager = class {
    * Detect purpose from file path based on extension
    */
   detectPurpose(filePath) {
-    const ext = path19.extname(filePath).toLowerCase();
+    const ext = path20.extname(filePath).toLowerCase();
     switch (ext) {
       case ".mp4":
       case ".mov":
@@ -59461,13 +60153,13 @@ var FileManager = class {
   cleanupTempFiles(output) {
     try {
       if (typeof output === "string") {
-        if (fs19.existsSync(output)) {
-          fs19.unlinkSync(output);
+        if (fs20.existsSync(output)) {
+          fs20.unlinkSync(output);
         }
       } else {
         for (const file of output) {
-          if (fs19.existsSync(file)) {
-            fs19.unlinkSync(file);
+          if (fs20.existsSync(file)) {
+            fs20.unlinkSync(file);
           }
         }
       }
@@ -59499,7 +60191,7 @@ var FileManager = class {
         }];
       }
       const localPath = this.fileCache.getLocalPath(entry.hash);
-      if (localPath && fs19.existsSync(localPath)) {
+      if (localPath && fs20.existsSync(localPath)) {
         return [{
           fileId,
           name: cacheEntry.name,
@@ -59596,12 +60288,12 @@ var FileManager = class {
       directories: []
     };
     try {
-      const entries = fs19.readdirSync(resolvedDir, { withFileTypes: true });
+      const entries = fs20.readdirSync(resolvedDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.name || entry.name.startsWith(".")) {
           continue;
         }
-        const fullPath = path19.join(resolvedDir, entry.name);
+        const fullPath = path20.join(resolvedDir, entry.name);
         if (entry.isDirectory()) {
           listing.directories.push({ name: entry.name, path: fullPath });
           continue;
@@ -59610,7 +60302,7 @@ var FileManager = class {
         let isFile = entry.isFile();
         if (entry.isSymbolicLink()) {
           try {
-            const targetStat = fs19.statSync(fullPath);
+            const targetStat = fs20.statSync(fullPath);
             isDirectory = targetStat.isDirectory();
             isFile = targetStat.isFile();
           } catch {
@@ -59628,7 +60320,7 @@ var FileManager = class {
         if (!type) {
           continue;
         }
-        const stat2 = fs19.statSync(fullPath);
+        const stat2 = fs20.statSync(fullPath);
         listing.files.push({
           name: entry.name,
           path: fullPath,
@@ -59642,7 +60334,7 @@ var FileManager = class {
     return listing;
   }
   invalidateDirectoryListingCacheForPath(filePath) {
-    this.directoryListingCache.delete(path19.dirname(resolvePath2(filePath)));
+    this.directoryListingCache.delete(path20.dirname(resolvePath2(filePath)));
   }
   buildAuthFingerprint(apiKey) {
     return crypto2.createHash("sha256").update(apiKey).digest("hex").slice(0, 16);
@@ -59691,8 +60383,8 @@ function createFileManagerForModel(params) {
     sessionId: params.sessionId,
     platform: platform2,
     apiKey: params.apiKey,
-    baseDir: path20.join(params.configDir, "files"),
-    sessionsDir: path20.join(params.configDir, "sessions")
+    baseDir: path21.join(params.configDir, "files"),
+    sessionsDir: path21.join(params.configDir, "sessions")
   });
   switch (getFileManagerAdapterKind(platform2)) {
     case "kimi":
@@ -59727,15 +60419,15 @@ function isInlineMediaRequest(request) {
   return request.kind === "image" || request.kind === "video";
 }
 async function prepareInlineMediaContent(params) {
-  const stat2 = await fs20.stat(params.request.absolutePath);
+  const stat2 = await fs21.stat(params.request.absolutePath);
   const limitMb = getCapabilityLimitMb(params.model, params.request.kind);
   const limitBytes = limitMb * 1024 * 1024;
   if (stat2.size > limitBytes) {
     throw new Error(
-      `${params.request.kind} understanding for ${params.model.provider}/${params.model.id} supports inline files up to ${limitMb}MB; ${path20.basename(params.request.displayPath)} is ${(stat2.size / 1024 / 1024).toFixed(1)}MB. Configure a model with a file upload adapter, or compress/trim the file before reading it.`
+      `${params.request.kind} understanding for ${params.model.provider}/${params.model.id} supports inline files up to ${limitMb}MB; ${path21.basename(params.request.displayPath)} is ${(stat2.size / 1024 / 1024).toFixed(1)}MB. Configure a model with a file upload adapter, or compress/trim the file before reading it.`
     );
   }
-  const data = await fs20.readFile(params.request.absolutePath, "base64");
+  const data = await fs21.readFile(params.request.absolutePath, "base64");
   const content = params.request.kind === "video" ? [{ type: "video", data, mimeType: params.request.mimeType }] : [{ type: "image", data, mimeType: params.request.mimeType }];
   return {
     content,
@@ -59755,7 +60447,7 @@ async function waitForReady(params) {
     if (status.status === "error" || status.status === "expired") {
       throw new Error(`Uploaded file is not ready: ${status.status}${status.error ? ` (${status.error})` : ""}`);
     }
-    await new Promise((resolve6) => setTimeout(resolve6, 1500));
+    await new Promise((resolve7) => setTimeout(resolve7, 1500));
   }
   throw new Error("Timed out waiting for uploaded file to become ready");
 }
@@ -59771,7 +60463,7 @@ async function prepareFileContent(configDir, params) {
   });
   if (params.request.kind === "document") {
     const upload2 = await manager.upload(params.request.absolutePath, {
-      sourceName: path20.basename(params.request.displayPath),
+      sourceName: path21.basename(params.request.displayPath),
       purpose: "file-extract"
     });
     await waitForReady({ manager, fileId: upload2.fileId, timeoutMs: 12e4, signal: params.request.signal });
@@ -59794,8 +60486,8 @@ async function prepareFileContent(configDir, params) {
       }
     };
   }
-  const upload = params.request.kind === "video" ? await manager.uploadVideo(params.request.absolutePath, { sourceName: path20.basename(params.request.displayPath), strategy: "compress" }) : await manager.upload(params.request.absolutePath, {
-    sourceName: path20.basename(params.request.displayPath),
+  const upload = params.request.kind === "video" ? await manager.uploadVideo(params.request.absolutePath, { sourceName: path21.basename(params.request.displayPath), strategy: "compress" }) : await manager.upload(params.request.absolutePath, {
+    sourceName: path21.basename(params.request.displayPath),
     purpose: params.request.kind === "image" ? "image" : "file-extract"
   });
   if (params.request.kind !== "video") {
@@ -59851,8 +60543,8 @@ function createIsolatedRegexSession(pattern, ignoreCase) {
   let initError;
   let readyResolve;
   let readyReject;
-  const ready = new Promise((resolve6, reject) => {
-    readyResolve = resolve6;
+  const ready = new Promise((resolve7, reject) => {
+    readyResolve = resolve7;
     readyReject = reject;
   });
   void ready.catch(() => void 0);
@@ -59874,7 +60566,7 @@ function createIsolatedRegexSession(pattern, ignoreCase) {
       if (initError) throw initError;
       if (signal?.aborted) throw new Error("Operation aborted");
       const id = nextId++;
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         let settled = false;
         const finish = (error, matches) => {
           if (settled) return;
@@ -59884,7 +60576,7 @@ function createIsolatedRegexSession(pattern, ignoreCase) {
           worker.off("message", onMessage);
           worker.off("error", onWorkerError);
           if (error) reject(error);
-          else resolve6(matches ?? []);
+          else resolve7(matches ?? []);
         };
         const terminate = (error) => {
           disposed = true;
@@ -60214,22 +60906,22 @@ var ExecutionStateManager = class {
 };
 
 // src/session-trace.ts
-import * as fs21 from "node:fs";
-import * as path21 from "node:path";
+import * as fs22 from "node:fs";
+import * as path22 from "node:path";
 function saveTraceFileBestEffort(tracePath, content) {
   const tempPath = `${tracePath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    fs21.writeFileSync(tempPath, content, "utf8");
+    fs22.writeFileSync(tempPath, content, "utf8");
     try {
-      fs21.renameSync(tempPath, tracePath);
+      fs22.renameSync(tempPath, tracePath);
       return;
     } catch {
       try {
-        fs21.copyFileSync(tempPath, tracePath);
+        fs22.copyFileSync(tempPath, tracePath);
       } catch {
       } finally {
         try {
-          fs21.unlinkSync(tempPath);
+          fs22.unlinkSync(tempPath);
         } catch {
         }
       }
@@ -60242,16 +60934,16 @@ var SessionTraceWriter = class extends SessionTraceSnapshotWriter {
     super({
       getSessionId: () => sessionManager.getActiveSessionId(),
       loadTrace: (sessionId) => {
-        const tracePath = path21.join(sessionsDir, `${sessionId}.trace.json`);
-        if (!fs21.existsSync(tracePath)) return null;
+        const tracePath = path22.join(sessionsDir, `${sessionId}.trace.json`);
+        if (!fs22.existsSync(tracePath)) return null;
         try {
-          return JSON.parse(fs21.readFileSync(tracePath, "utf8"));
+          return JSON.parse(fs22.readFileSync(tracePath, "utf8"));
         } catch {
           return null;
         }
       },
       saveTrace: (trace) => {
-        const tracePath = path21.join(sessionsDir, `${trace.sessionId}.trace.json`);
+        const tracePath = path22.join(sessionsDir, `${trace.sessionId}.trace.json`);
         saveTraceFileBestEffort(tracePath, JSON.stringify(trace, null, 2));
       }
     });
@@ -60758,7 +61450,7 @@ function normalizeSessionTitle(raw) {
 }
 
 // src/components/extension-selector.ts
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 var ExtensionSelectorComponent = class extends Container {
   selectList;
   constructor(title, options, onSelect, onCancel) {
@@ -60828,8 +61520,8 @@ var ExtensionStateSubmenu = class extends Container {
   }
 };
 function unidentifiedLabel(info) {
-  const parentName = path22.basename(path22.dirname(info.entryPath));
-  const fileName = path22.basename(info.entryPath);
+  const parentName = path23.basename(path23.dirname(info.entryPath));
+  const fileName = path23.basename(info.entryPath);
   return `(unidentified) ${parentName || fileName}`;
 }
 var ExtensionEnablementSelectorComponent = class extends Container {
@@ -61119,7 +61811,7 @@ async function handleCacheTest(host) {
     host.chatContainer.addChild(new Text(theme.fg("dim", `  ${summarizeUsage(result1.usage)}`), 1, 0));
     host.chatContainer.addChild(new Text(theme.fg("dim", "  Waiting 2s before replaying identical request..."), 1, 0));
     host.ui.requestRender();
-    await new Promise((resolve6) => setTimeout(resolve6, 2e3));
+    await new Promise((resolve7) => setTimeout(resolve7, 2e3));
     host.chatContainer.addChild(new Text(theme.fg("accent", "Request 2/2: replaying identical request..."), 1, 0));
     host.ui.requestRender();
     result2 = await completeSimple(model, context, options);
@@ -61300,10 +61992,10 @@ async function handleDebugPackageCommand(host) {
 }
 
 // src/commands/interactive-session-commands.ts
-import * as os5 from "os";
+import * as os6 from "os";
 
 // src/components/session-selector.ts
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 function formatDate(timestamp) {
   const date = new Date(timestamp);
   const now = /* @__PURE__ */ new Date();
@@ -61334,7 +62026,7 @@ function getPathFlavor(value, peer) {
   return "posix";
 }
 function getPathApi(flavor) {
-  return flavor === "windows" ? path23.win32 : path23.posix;
+  return flavor === "windows" ? path24.win32 : path24.posix;
 }
 function normalizeForComparison(value, flavor) {
   const pathApi = getPathApi(flavor);
@@ -61354,10 +62046,10 @@ function formatSessionCwdTag(sessionCwd, currentCwd, homeDir) {
   const normalizedSessionCwd = pathApi.normalize(sessionCwd);
   if (homeDir && getPathFlavor(homeDir, sessionCwd) === sessionFlavor) {
     const normalizedHome = pathApi.normalize(homeDir);
-    const relative2 = pathApi.relative(normalizedHome, normalizedSessionCwd);
-    const outsideHome = relative2 === ".." || relative2.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(relative2);
+    const relative3 = pathApi.relative(normalizedHome, normalizedSessionCwd);
+    const outsideHome = relative3 === ".." || relative3.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(relative3);
     if (!outsideHome) {
-      return relative2 ? `~${pathApi.sep}${relative2}` : "~";
+      return relative3 ? `~${pathApi.sep}${relative3}` : "~";
     }
   }
   return normalizedSessionCwd;
@@ -62007,7 +62699,7 @@ var AssistantMessageComponent = class extends Container {
 };
 
 // src/components/tool-execution.ts
-import * as os4 from "node:os";
+import * as os5 from "node:os";
 
 // ../../node_modules/diff/libesm/diff/base.js
 var Diff = class {
@@ -62109,16 +62801,16 @@ var Diff = class {
       }
     }
   }
-  addToPath(path31, added, removed, oldPosInc, options) {
-    const last = path31.lastComponent;
+  addToPath(path33, added, removed, oldPosInc, options) {
+    const last = path33.lastComponent;
     if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
       return {
-        oldPos: path31.oldPos + oldPosInc,
+        oldPos: path33.oldPos + oldPosInc,
         lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
       };
     } else {
       return {
-        oldPos: path31.oldPos + oldPosInc,
+        oldPos: path33.oldPos + oldPosInc,
         lastComponent: { count: 1, added, removed, previousComponent: last }
       };
     }
@@ -62566,13 +63258,13 @@ function formatSize2(bytes) {
 }
 var DEFAULT_MAX_BYTES = 102400;
 var DEFAULT_MAX_LINES = 100;
-function shortenPath(path31) {
-  if (typeof path31 !== "string") return "";
-  const home = os4.homedir();
-  if (path31.startsWith(home)) {
-    return `~${path31.slice(home.length)}`;
+function shortenPath(path33) {
+  if (typeof path33 !== "string") return "";
+  const home = os5.homedir();
+  if (path33.startsWith(home)) {
+    return `~${path33.slice(home.length)}`;
   }
-  return path31;
+  return path33;
 }
 function replaceTabs(text) {
   return text.replace(/\t/g, "   ");
@@ -62598,11 +63290,13 @@ var ToolExecutionComponent = class extends Container {
   isPartial = true;
   ui;
   result;
+  renderHint;
   constructor(toolName, args, options = {}, ui) {
     super();
     this.toolName = toolName;
     this.args = args;
     this.expanded = options.expanded ?? false;
+    this.renderHint = options.renderHint;
     this.ui = ui;
     this.addChild(new Spacer(1));
     this.contentBox = new Box(1, 1, (text) => theme.bg("toolPendingBg", text));
@@ -62653,14 +63347,14 @@ ${renderManageTodoListResult(this.result, { expanded: this.expanded }, theme)}`;
       }
     } else if (this.toolName === "read_file") {
       const rawPath = str(this.args?.file_path ?? this.args?.path);
-      const path31 = rawPath !== null ? shortenPath(rawPath) : null;
+      const path33 = rawPath !== null ? shortenPath(rawPath) : null;
       const offset = typeof this.args?.offset === "number" ? this.args.offset : void 0;
       const limit = typeof this.args?.limit === "number" ? this.args.limit : void 0;
       let pathDisplay;
-      if (path31 === null) {
+      if (path33 === null) {
         pathDisplay = invalidArg;
-      } else if (path31) {
-        pathDisplay = theme.fg("accent", path31);
+      } else if (path33) {
+        pathDisplay = theme.fg("accent", path33);
       } else {
         const partialPath = partialStr(this.args?.file_path ?? this.args?.path);
         pathDisplay = theme.fg("toolOutput", partialPath);
@@ -62707,12 +63401,12 @@ ${renderManageTodoListResult(this.result, { expanded: this.expanded }, theme)}`;
     } else if (this.toolName === "write_file") {
       const rawPath = str(this.args?.file_path ?? this.args?.path);
       const fileContent = str(this.args?.content);
-      const path31 = rawPath !== null ? shortenPath(rawPath) : null;
+      const path33 = rawPath !== null ? shortenPath(rawPath) : null;
       let pathDisplay;
-      if (path31 === null) {
+      if (path33 === null) {
         pathDisplay = invalidArg;
-      } else if (path31) {
-        pathDisplay = theme.fg("accent", path31);
+      } else if (path33) {
+        pathDisplay = theme.fg("accent", path33);
       } else {
         const partialPath = partialStr(this.args?.file_path ?? this.args?.path);
         pathDisplay = theme.fg("toolOutput", partialPath);
@@ -62749,12 +63443,12 @@ ${theme.fg("error", errorText)}`;
       }
     } else if (this.toolName === "edit_file") {
       const rawPath = str(this.args?.file_path ?? this.args?.path);
-      const path31 = rawPath !== null ? shortenPath(rawPath) : null;
+      const path33 = rawPath !== null ? shortenPath(rawPath) : null;
       let pathDisplay;
-      if (path31 === null) {
+      if (path33 === null) {
         pathDisplay = invalidArg;
-      } else if (path31) {
-        pathDisplay = theme.fg("accent", path31);
+      } else if (path33) {
+        pathDisplay = theme.fg("accent", path33);
       } else {
         const partialPath = partialStr(this.args?.file_path ?? this.args?.path);
         pathDisplay = theme.fg("toolOutput", partialPath);
@@ -62779,7 +63473,7 @@ ${theme.fg("error", errorText)}`;
         const diff = this.result.details.diff;
         const firstChangedLine = this.result.details.firstChangedLine;
         if (firstChangedLine) {
-          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path31 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
+          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path33 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
         }
         const lines = diff.split("\n");
         const maxLines = this.expanded ? lines.length : 15;
@@ -62799,7 +63493,7 @@ ${theme.fg("error", errorText)}`;
         const diff = generateEditDiff(oldText, newText, rawPath);
         const firstChangedLine = findFirstChangedLine(oldText, newText);
         if (firstChangedLine) {
-          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path31 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
+          text = `${theme.fg("toolTitle", theme.bold("edit_file"))} ${theme.fg("accent", path33 || rawPath)}${theme.fg("warning", `:${firstChangedLine}`)}`;
         }
         const lines = diff.split("\n");
         const maxLines = this.expanded ? lines.length : 15;
@@ -62818,9 +63512,9 @@ ${theme.fg("error", errorText)}`;
       }
     } else if (this.toolName === "list_dir") {
       const rawPath = str(this.args?.path);
-      const path31 = rawPath !== null ? shortenPath(rawPath || ".") : null;
+      const path33 = rawPath !== null ? shortenPath(rawPath || ".") : null;
       const limit = this.args?.limit;
-      text = `${theme.fg("toolTitle", theme.bold("list_dir"))} ${path31 === null ? invalidArg : theme.fg("accent", path31)}`;
+      text = `${theme.fg("toolTitle", theme.bold("list_dir"))} ${path33 === null ? invalidArg : theme.fg("accent", path33)}`;
       if (limit !== void 0) {
         text += theme.fg("toolOutput", ` (limit ${limit})`);
       }
@@ -62856,9 +63550,9 @@ ${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
     } else if (this.toolName === "find_files") {
       const pattern = str(this.args?.pattern);
       const rawPath = str(this.args?.path);
-      const path31 = rawPath !== null ? shortenPath(rawPath || ".") : null;
+      const path33 = rawPath !== null ? shortenPath(rawPath || ".") : null;
       const limit = this.args?.limit;
-      text = theme.fg("toolTitle", theme.bold("find_files")) + " " + (pattern === null ? invalidArg : theme.fg("accent", pattern || "")) + theme.fg("toolOutput", ` in ${path31 === null ? invalidArg : path31}`);
+      text = theme.fg("toolTitle", theme.bold("find_files")) + " " + (pattern === null ? invalidArg : theme.fg("accent", pattern || "")) + theme.fg("toolOutput", ` in ${path33 === null ? invalidArg : path33}`);
       if (limit !== void 0) {
         text += theme.fg("toolOutput", ` (limit ${limit})`);
       }
@@ -62894,10 +63588,10 @@ ${theme.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
     } else if (this.toolName === "grep_text") {
       const pattern = str(this.args?.pattern);
       const rawPath = str(this.args?.path);
-      const path31 = rawPath !== null ? shortenPath(rawPath || ".") : null;
+      const path33 = rawPath !== null ? shortenPath(rawPath || ".") : null;
       const glob = str(this.args?.glob);
       const limit = this.args?.limit;
-      text = theme.fg("toolTitle", theme.bold("grep_text")) + " " + (pattern === null ? invalidArg : theme.fg("accent", `/${pattern || ""}/`)) + theme.fg("toolOutput", ` in ${path31 === null ? invalidArg : path31}`);
+      text = theme.fg("toolTitle", theme.bold("grep_text")) + " " + (pattern === null ? invalidArg : theme.fg("accent", `/${pattern || ""}/`)) + theme.fg("toolOutput", ` in ${path33 === null ? invalidArg : path33}`);
       if (glob) {
         text += theme.fg("toolOutput", ` (${glob})`);
       }
@@ -62977,33 +63671,97 @@ ${theme.fg("warning", `[${warnings.join(". ")}]`)}`;
         }
       }
     } else {
-      text = theme.fg("toolTitle", theme.bold(this.toolName));
-      if (this.args && Object.keys(this.args).length > 0) {
-        const content = JSON.stringify(this.args, null, 2);
-        text += `
-
-${theme.fg("toolOutput", content)}`;
+      const hinted = this.formatWithRenderHint();
+      if (hinted !== null) {
+        text = hinted;
+      } else {
+        text = this.formatGenericTool();
       }
-      if (this.result) {
-        const output = this.getTextOutput();
-        if (output) {
-          const lines = output.split("\n");
-          const maxLines = this.expanded ? lines.length : 20;
-          const displayLines = lines.slice(0, maxLines);
-          const remaining = lines.length - maxLines;
-          text += "\n\n" + displayLines.map((line) => theme.fg("toolOutput", line)).join("\n");
-          if (remaining > 0) {
-            text += theme.fg("muted", `
+    }
+    return text;
+  }
+  /** Render via the extension renderHint; null means fall back. */
+  formatWithRenderHint() {
+    const hint = this.renderHint;
+    if (!hint) return null;
+    try {
+      let text = theme.fg("toolTitle", theme.bold(this.toolName));
+      let produced = false;
+      if (hint.summary) {
+        const summary = hint.summary(this.args);
+        if (typeof summary === "string" && summary.trim()) {
+          text += ` ${theme.fg("accent", summary.trim())}`;
+          produced = true;
+        }
+      }
+      if (this.result && hint.sections) {
+        const sections = hint.sections(
+          this.result,
+          { expanded: this.expanded }
+        );
+        if (Array.isArray(sections)) {
+          for (const section of sections) {
+            if (!section || typeof section.text !== "string" || !section.text) continue;
+            produced = true;
+            if (section.title) {
+              text += `
+
+${theme.fg("toolTitle", section.title)}`;
+            }
+            const lines = section.text.split("\n");
+            const maxLines = this.expanded ? lines.length : 20;
+            const displayLines = lines.slice(0, maxLines);
+            const remaining = lines.length - maxLines;
+            text += "\n" + displayLines.map((line) => theme.fg("toolOutput", line)).join("\n");
+            if (remaining > 0) {
+              text += theme.fg("muted", `
 ... (${remaining} more lines, press Ctrl+O to expand)`);
+            }
           }
         }
-        if (this.result.isError) {
-          const errorOutput = this.getTextOutput() || "Unknown error";
-          text += `
+      }
+      if (!produced) return null;
+      if (this.result?.isError) {
+        const errorOutput = this.getTextOutput() || "Unknown error";
+        text += `
 
 ${theme.fg("error", "Error: " + errorOutput)}`;
+      }
+      return text;
+    } catch (error) {
+      if (process.env.PIE_VERBOSE) {
+        console.warn(`[ToolExecution] renderHint for ${this.toolName} failed, falling back:`, error);
+      }
+      return null;
+    }
+  }
+  formatGenericTool() {
+    let text = theme.fg("toolTitle", theme.bold(this.toolName));
+    if (this.args && Object.keys(this.args).length > 0) {
+      const content = JSON.stringify(this.args, null, 2);
+      text += `
+
+${theme.fg("toolOutput", content)}`;
+    }
+    if (this.result) {
+      const output = this.getTextOutput();
+      if (output) {
+        const lines = output.split("\n");
+        const maxLines = this.expanded ? lines.length : 20;
+        const displayLines = lines.slice(0, maxLines);
+        const remaining = lines.length - maxLines;
+        text += "\n\n" + displayLines.map((line) => theme.fg("toolOutput", line)).join("\n");
+        if (remaining > 0) {
+          text += theme.fg("muted", `
+... (${remaining} more lines, press Ctrl+O to expand)`);
         }
       }
+      if (this.result.isError) {
+        const errorOutput = this.getTextOutput() || "Unknown error";
+        text += `
+
+${theme.fg("error", "Error: " + errorOutput)}`;
+      }
     }
     return text;
   }
@@ -63048,7 +63806,7 @@ async function handleResumeCommand(host) {
       }
     }, {
       currentCwd: host.options.cwd,
-      homeDir: os5.homedir(),
+      homeDir: os6.homedir(),
       refreshMetadata: (sessionId) => host.sessionManager.refreshDerivedName(sessionId),
       requestRender: () => host.ui.requestRender(),
       totalCount
@@ -63057,6 +63815,15 @@ async function handleResumeCommand(host) {
   });
 }
 async function loadSession(host, sessionId) {
+  const beforeSwitch = await host.extensionRunner?.emitSessionBeforeSwitch({
+    type: "session:before_switch",
+    reason: "resume",
+    targetSessionId: sessionId
+  });
+  if (beforeSwitch?.cancel) {
+    host.showStatus("Session switch cancelled by an extension");
+    return;
+  }
   try {
     const success = await host.sessionManager.loadSession(sessionId);
     if (!success) {
@@ -63351,8 +64118,8 @@ async function forkAtEntry(host, entryId) {
       host.showError("Failed to branch at entry");
       return;
     }
-    const path31 = host.sessionManager.getPathToEntry(entryId);
-    const pathNames = path31.map((e) => e.message?.role || "entry").join(" \u2192 ");
+    const path33 = host.sessionManager.getPathToEntry(entryId);
+    const pathNames = path33.map((e) => e.message?.role || "entry").join(" \u2192 ");
     const messages = host.sessionManager.getMessages();
     host.syncAgentFromActiveSession(messages);
     await host.syncSessionScopedState(messages);
@@ -63365,7 +64132,7 @@ async function forkAtEntry(host, entryId) {
     host.updatePendingMessagesDisplay();
     host.renderMessageHistory(messages);
     await host.sessionManager.save();
-    host.showStatus(`Branched at: ${pathNames} (${path31.length} messages). Continue to add to this branch.`);
+    host.showStatus(`Branched at: ${pathNames} (${path33.length} messages). Continue to add to this branch.`);
   } catch (error) {
     host.showError(
       `Failed to branch: ${error instanceof Error ? error.message : String(error)}`
@@ -63393,10 +64160,10 @@ async function navigateToEntry(host, entryId) {
     host.sessionManager.save().catch((err) => {
       console.error("[Session] Save after navigation failed:", err);
     });
-    const path31 = host.sessionManager.getPathToEntry(entryId);
+    const path33 = host.sessionManager.getPathToEntry(entryId);
     const entry = host.sessionManager.getEntry(entryId);
     const role = entry?.message?.role || "entry";
-    host.showStatus(`Switched to branch: ${role} (${path31.length} messages in path)`);
+    host.showStatus(`Switched to branch: ${role} (${path33.length} messages in path)`);
   } catch (error) {
     host.showError(
       `Failed to navigate: ${error instanceof Error ? error.message : String(error)}`
@@ -63446,9 +64213,9 @@ async function handleForkCommand(host) {
 }
 
 // src/commands/interactive-skill-commands.ts
-import * as fs22 from "fs";
-import * as os6 from "os";
-import * as path24 from "path";
+import * as fs23 from "fs";
+import * as os7 from "os";
+import * as path25 from "path";
 
 // src/commands/subagent-command.ts
 async function handleSubagentCommand(host, args) {
@@ -63633,7 +64400,7 @@ function expandSkillCommand(host, text) {
   const skill = host.skills.find((s) => s.name === skillName);
   if (!skill) return text;
   try {
-    const content = fs22.readFileSync(skill.filePath, "utf-8");
+    const content = fs23.readFileSync(skill.filePath, "utf-8");
     const body = host.stripFrontmatter(content).trim();
     const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">
 References are relative to ${skill.baseDir}.
@@ -63699,17 +64466,17 @@ async function handleSkillsCreate(host, args) {
     if (!description) {
       description = `Skill for ${name}`;
     }
-    const skillsDir = path24.join(os6.homedir(), ".pie", "skills");
-    const skillDir = path24.join(skillsDir, name);
-    const skillFile = path24.join(skillDir, "SKILL.md");
+    const skillsDir = path25.join(os7.homedir(), ".pie", "skills");
+    const skillDir = path25.join(skillsDir, name);
+    const skillFile = path25.join(skillDir, "SKILL.md");
     console.error(`[SkillsCreate] Creating at: ${skillFile}`);
-    if (fs22.existsSync(skillDir)) {
+    if (fs23.existsSync(skillDir)) {
       host.showError(`Skill "${name}" already exists at ${skillDir}`);
       return;
     }
-    fs22.mkdirSync(skillDir, { recursive: true });
+    fs23.mkdirSync(skillDir, { recursive: true });
     const template = createSkillTemplate(name, description);
-    fs22.writeFileSync(skillFile, template, "utf-8");
+    fs23.writeFileSync(skillFile, template, "utf-8");
     console.error(`[SkillsCreate] Successfully created skill`);
     host.chatContainer.addChild(new Spacer(1));
     host.chatContainer.addChild(new Text(theme.fg("accent", `\u2713 Created skill: ${name}`), 1, 0));
@@ -63745,10 +64512,10 @@ async function handleSkillsReload(host) {
   host.chatContainer.addChild(new Text(theme.fg("accent", "Reloading skills..."), 1, 0));
   host.ui.requestRender();
   try {
-    const builtinDir = path24.join(getBuiltinDir(), "skills");
-    const userDir = path24.join(os6.homedir(), ".pie", "skills");
-    const projectDir = path24.join(process.cwd(), ".pie", "skills");
-    const result = loadSkills({ builtinDir, userDir, projectDir });
+    const builtinDir = path25.join(getBuiltinDir(), "skills");
+    const userDir = path25.join(os7.homedir(), ".pie", "skills");
+    const projectDir = path25.join(process.cwd(), ".pie", "skills");
+    const result = loadSkills({ dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: process.cwd() }) });
     host.skills = result.skills;
     host.skillsSection = formatSkillsForPrompt(host.skills);
     host.applyRuntimeToolMode(host.allTools.length > 0 ? host.allTools : host.agent.state.tools);
@@ -63763,8 +64530,8 @@ async function handleSkillsReload(host) {
       }
     }
     const builtinCount = host.skills.filter((s) => s.source === "builtin").length;
-    const userCount = host.skills.filter((s) => s.source === "user").length;
-    const projectCount = host.skills.filter((s) => s.source === "project").length;
+    const userCount = host.skills.filter((s) => s.source === "user" || s.source === "user-agents").length;
+    const projectCount = host.skills.filter((s) => s.source === "project" || s.source === "project-agents").length;
     host.chatContainer.addChild(new Text(theme.fg("accent", `\u2713 Reloaded ${host.skills.length} skill(s)`), 1, 0));
     host.chatContainer.addChild(new Text(theme.fg("dim", `  Builtin: ${builtinCount}, User: ${userCount}, Project: ${projectCount}`), 1, 0));
     if (result.diagnostics.length > 0) {
@@ -64135,6 +64902,14 @@ function showThinkingLevelSelector(host) {
   });
 }
 async function handleClearCommand(host) {
+  const beforeSwitch = await host.extensionRunner?.emitSessionBeforeSwitch({
+    type: "session:before_switch",
+    reason: "new"
+  });
+  if (beforeSwitch?.cancel) {
+    host.showStatus("Session switch cancelled by an extension");
+    return;
+  }
   host.setControllerBusy(false);
   host.setWaitingForUser(false);
   host.executionState.clear();
@@ -64433,7 +65208,21 @@ async function handleCompactCommand(host) {
       apiKey: host.options.apiKey,
       systemPrompt: host.agent.state.systemPrompt
     };
-    const summary = await createCompactionSummary(existingMessages, compactOptions);
+    let summary;
+    const beforeCompact = await host.extensionRunner?.emitSessionBeforeCompact({
+      type: "session:before_compact",
+      reason: "manual",
+      messageCount: existingMessages.length
+    });
+    if (beforeCompact?.cancel) {
+      host.showStatus("Compaction cancelled by an extension");
+      return;
+    }
+    if (beforeCompact?.summary) {
+      summary = beforeCompact.summary;
+    } else {
+      summary = await createCompactionSummary(existingMessages, compactOptions);
+    }
     const tokensBefore = calculateTotalTokens(existingMessages);
     host.sessionManager.appendCompaction(summary, firstKeptEntryId, tokensBefore);
     const compactedMessages = host.sessionManager.getMessages();
@@ -64496,6 +65285,31 @@ function formatFooterLifecycleEvent(event) {
   }
 }
 
+// src/runtime/terminal-bell.ts
+var BEL = "\x07";
+var DEFAULT_MIN_INTERVAL_MS = 500;
+var lastRingAtMs = 0;
+function ringTerminalBell(options = {}) {
+  const {
+    enabled = true,
+    stdout = process.stdout,
+    now = Date.now,
+    minIntervalMs = DEFAULT_MIN_INTERVAL_MS
+  } = options;
+  if (!enabled) return false;
+  if (!stdout.isTTY) return false;
+  const atMs = now();
+  if (atMs - lastRingAtMs < minIntervalMs) return false;
+  lastRingAtMs = atMs;
+  stdout.write(BEL);
+  return true;
+}
+function ringTurnSettledBell(host) {
+  if ((host.agentSessionController?.pendingMessageCount ?? 0) > 0) return;
+  if (host.executionState.read().awaitingContinuation) return;
+  host.ringAttentionBell?.();
+}
+
 // src/runtime/interactive-runtime-events.ts
 function bindInteractiveRuntimeEvents(host) {
   host.agent.subscribe((event) => {
@@ -64666,6 +65480,7 @@ function handleSemanticAgentEvent(host, event) {
         host.appendWarningSummary(outcome.terminalSummary);
       }
       host.sessionTrace.completeTurn(event.message, false);
+      ringTurnSettledBell(host);
       host._semanticTurnIndex++;
       break;
     }
@@ -64700,6 +65515,7 @@ function handleSemanticAgentEvent(host, event) {
         host.appendWarningSummary(outcome.terminalSummary);
       }
       host.sessionTrace.completeTurn(event.message, true);
+      host.ringAttentionBell?.();
       host._semanticTurnIndex++;
       break;
     }
@@ -64748,6 +65564,7 @@ function handleMessageStart(host, event) {
   host.safeRequestRender();
 }
 function handleMessageUpdate(host, event) {
+  host.noteContinuationActivity?.();
   if (!host.streamingComponent || event.message?.role !== "assistant") return;
   host.sessionTrace.updateAssistantMessage(event.message);
   if (host.isComposing) {
@@ -64784,7 +65601,7 @@ function handleMessageUpdate(host, event) {
           const toolComponent = new ToolExecutionComponent(
             toolCall.name,
             toolCall.arguments,
-            { expanded: host.toolOutputExpanded },
+            { expanded: host.toolOutputExpanded, renderHint: findToolRenderHint(host, toolCall.name) },
             host.ui
           );
           host.pendingTools.set(toolId, toolComponent);
@@ -64820,6 +65637,15 @@ function handleMessageUpdate(host, event) {
   });
   host.safeRequestRender();
 }
+function findToolRenderHint(host, toolName) {
+  const tools = host.agent?.state?.tools ?? [];
+  for (const tool of tools) {
+    if (tool.name !== toolName) continue;
+    const hint = tool.renderHint;
+    if (hint) return hint;
+  }
+  return void 0;
+}
 function handleToolStart(host, event) {
   host.logDebug("tool:start", { toolName: event.toolName, toolCallId: event.toolCallId });
   host.sessionTrace.startTool(event.toolCallId, event.toolName, event.args);
@@ -64831,7 +65657,7 @@ function handleToolStart(host, event) {
       const newToolComponent = new ToolExecutionComponent(
         event.toolName,
         event.args,
-        { expanded: host.toolOutputExpanded },
+        { expanded: host.toolOutputExpanded, renderHint: findToolRenderHint(host, event.toolName) },
         host.ui
       );
       host.pendingTools.set(event.toolCallId, newToolComponent);
@@ -64848,6 +65674,7 @@ function handleToolStart(host, event) {
   host.safeRequestRender();
 }
 function handleToolUpdate(host, event) {
+  host.noteContinuationActivity?.();
   if (event.toolCallId) {
     const toolComponent = host.pendingTools.get(event.toolCallId);
     if (toolComponent) {
@@ -64924,6 +65751,20 @@ function setupInteractiveEditorSubmitHandler(host) {
   host.editor.onSubmit = async (text) => {
     text = text.trim();
     if (!text) return;
+    if (host.extensionRunner) {
+      const decision = await host.extensionRunner.emitTerminalInput({ type: "terminal:input", text });
+      if (decision.action === "consume") {
+        host.editor.setText("");
+        return;
+      }
+      if (decision.action === "transform") {
+        text = decision.text.trim();
+        if (!text) {
+          host.editor.setText("");
+          return;
+        }
+      }
+    }
     if (text.startsWith("/skills/skill:")) {
       const skillText = text.slice("/skills/".length);
       const expanded = host.expandSkillCommand(skillText);
@@ -65186,7 +66027,7 @@ function setupInteractiveEditorSubmitHandler(host) {
     host.chatContainer.addChild(userMsg);
     host.editor.setText("");
     host.ui.requestRender();
-    await new Promise((resolve6) => setImmediate(resolve6));
+    await new Promise((resolve7) => setImmediate(resolve7));
     let finalContent = messageContent;
     const reminderPrefix = host.executionReminder;
     const combinedPrefix = [reminderPrefix].filter((value) => Boolean(value)).join("");
@@ -65222,8 +66063,8 @@ function setupInteractiveEditorSubmitHandler(host) {
 }
 
 // src/input/interactive-file-pipeline.ts
-import * as fs25 from "fs";
-import * as path27 from "path";
+import * as fs26 from "fs";
+import * as path28 from "path";
 
 // src/components/file-picker.ts
 var FilePickerComponent = class extends Container {
@@ -65444,8 +66285,8 @@ var FilePickerComponent = class extends Container {
 };
 
 // src/files/commands/file-commands.ts
-import * as fs23 from "node:fs";
-import * as path25 from "node:path";
+import * as fs24 from "node:fs";
+import * as path26 from "node:path";
 var FileCommands = class {
   context;
   constructor(context) {
@@ -65461,11 +66302,11 @@ var FileCommands = class {
       return;
     }
     const filePath = resolvePath2(parsed.path);
-    if (!fs23.existsSync(filePath)) {
+    if (!fs24.existsSync(filePath)) {
       this.context.showError(`File not found: ${parsed.path}`);
       return;
     }
-    this.context.showStatus(`Uploading ${path25.basename(filePath)}...`);
+    this.context.showStatus(`Uploading ${path26.basename(filePath)}...`);
     try {
       const result = await this.context.fileManager.upload(filePath, {
         purpose: parsed.purpose,
@@ -65500,7 +66341,7 @@ var FileCommands = class {
       return;
     }
     const resolvedPath = resolvePath2(filePath);
-    if (!fs23.existsSync(resolvedPath)) {
+    if (!fs24.existsSync(resolvedPath)) {
       this.context.showError(`File not found: ${filePath}`);
       return;
     }
@@ -65531,7 +66372,7 @@ var FileCommands = class {
       return;
     }
     const resolvedPath = resolvePath2(parsed.path);
-    if (!fs23.existsSync(resolvedPath)) {
+    if (!fs24.existsSync(resolvedPath)) {
       this.context.showError(`File not found: ${parsed.path}`);
       return;
     }
@@ -66009,8 +66850,8 @@ var FileStatusMonitor = class {
 };
 
 // src/files/mention/mention-handler.ts
-import * as fs24 from "node:fs";
-import * as path26 from "node:path";
+import * as fs25 from "node:fs";
+import * as path27 from "node:path";
 var MentionHandler = class {
   fileManager;
   onShowPicker;
@@ -66065,7 +66906,7 @@ var MentionHandler = class {
   navigateBrowseParent() {
     const currentDir = this.getBrowserDirectory();
     if (!currentDir) return;
-    const parentDir = path26.dirname(currentDir);
+    const parentDir = path27.dirname(currentDir);
     if (parentDir === currentDir) return;
     this.browsingDirectory = parentDir;
     this.showMentionPicker("");
@@ -66085,7 +66926,7 @@ var MentionHandler = class {
     if (option.type === "parent") {
       const currentDir = this.getBrowserDirectory();
       if (currentDir) {
-        this.browsingDirectory = path26.dirname(currentDir);
+        this.browsingDirectory = path27.dirname(currentDir);
         this.showMentionPicker("");
         this.isPickerVisible = true;
       }
@@ -66221,7 +67062,7 @@ var MentionHandler = class {
         id: part.content,
         name: part.name || fileInfo.name,
         mimeType: fileInfo.mimeType,
-        ext: path26.extname(part.name || fileInfo.name).toLowerCase(),
+        ext: path27.extname(part.name || fileInfo.name).toLowerCase(),
         size: fileInfo.size,
         source: fileInfo.platforms.length > 0 ? "session" : "local",
         fileId: part.content,
@@ -66379,11 +67220,11 @@ var MentionHandler = class {
     }
     if (this.isPath(query)) {
       const resolvedPath = resolvePath2(query);
-      if (fs24.existsSync(resolvedPath)) {
-        const stats = fs24.statSync(resolvedPath);
+      if (fs25.existsSync(resolvedPath)) {
+        const stats = fs25.statSync(resolvedPath);
         if (stats.isFile()) {
           const type = FileCache.getFileTypeFromName(resolvedPath);
-          const name = path26.basename(resolvedPath);
+          const name = path27.basename(resolvedPath);
           if (!seenNames.has(name.toLowerCase())) {
             options.push({
               type: "upload",
@@ -66404,16 +67245,16 @@ var MentionHandler = class {
       return void 0;
     }
     const queryPath = this.isPath(query) ? resolvePath2(query) : void 0;
-    const filter = queryPath ? fs24.existsSync(queryPath) && fs24.statSync(queryPath).isDirectory() ? "" : path26.basename(queryPath) : query;
+    const filter = queryPath ? fs25.existsSync(queryPath) && fs25.statSync(queryPath).isDirectory() ? "" : path27.basename(queryPath) : query;
     const entries = this.fileManager.listPathEntries(currentDir, filter);
     const options = [];
     const homeDir = process.env.HOME || "";
     const displayDir = currentDir.startsWith(homeDir) ? `~${currentDir.slice(homeDir.length)}` : currentDir;
-    if (path26.dirname(currentDir) !== currentDir) {
+    if (path27.dirname(currentDir) !== currentDir) {
       options.push({
         type: "parent",
         name: "..",
-        path: path26.dirname(currentDir),
+        path: path27.dirname(currentDir),
         icon: "\u21A9",
         meta: "Parent directory"
       });
@@ -66445,10 +67286,10 @@ var MentionHandler = class {
   getBrowserDirectory(query = this.currentQuery) {
     if (this.isPath(query)) {
       const resolvedPath = resolvePath2(query);
-      if (fs24.existsSync(resolvedPath) && fs24.statSync(resolvedPath).isDirectory()) {
+      if (fs25.existsSync(resolvedPath) && fs25.statSync(resolvedPath).isDirectory()) {
         return resolvedPath;
       }
-      return path26.dirname(resolvedPath);
+      return path27.dirname(resolvedPath);
     }
     return this.browsingDirectory;
   }
@@ -66535,8 +67376,8 @@ async function initializeFileManager(host) {
     sessionId,
     platform: platform2,
     apiKey: host.options.apiKey,
-    baseDir: path27.join(host.options.configDir, "files"),
-    sessionsDir: path27.join(host.options.configDir, "sessions")
+    baseDir: path28.join(host.options.configDir, "files"),
+    sessionsDir: path28.join(host.options.configDir, "sessions")
   });
   switch (getFileManagerAdapterKind(host.options.model?.filePlatform)) {
     case "kimi":
@@ -66809,13 +67650,13 @@ function convertPreparedAttachmentItems(items) {
         break;
       case "image": {
         if (!item.data && !item.path) return void 0;
-        const data = item.data ?? fs25.readFileSync(item.path, "base64");
+        const data = item.data ?? fs26.readFileSync(item.path, "base64");
         converted.push({ type: "image", data, mimeType: item.mimeType });
         break;
       }
       case "video": {
         if (!item.data && !item.path) return void 0;
-        const data = item.data ?? fs25.readFileSync(item.path, "base64");
+        const data = item.data ?? fs26.readFileSync(item.path, "base64");
         converted.push({ type: "video", data, mimeType: item.mimeType });
         break;
       }
@@ -67036,6 +67877,55 @@ function isCommandLikeInput(text) {
   return text.startsWith("/") || text.startsWith("!!");
 }
 
+// src/components/extension-widgets.ts
+var ExtensionWidgetsComponent = class extends Container {
+  slots = /* @__PURE__ */ new Map();
+  setWidget(key, lines) {
+    const normalized = (lines ?? []).map((line) => String(line ?? "")).filter((line) => line.trim().length > 0);
+    if (normalized.length === 0) {
+      this.slots.delete(key);
+    } else {
+      this.slots.set(key, normalized.slice(0, 3));
+    }
+    this.rebuild();
+  }
+  clearAll() {
+    if (this.slots.size === 0) return;
+    this.slots.clear();
+    this.rebuild();
+  }
+  rebuild() {
+    this.clear();
+    for (const lines of this.slots.values()) {
+      for (const line of lines) {
+        this.addChild(new Text(theme.fg("dim", `\xB7 ${line}`), 1, 0));
+      }
+    }
+  }
+};
+var ExtensionStatusSlots = class {
+  slots = /* @__PURE__ */ new Map();
+  set(key, text) {
+    const normalized = String(text ?? "").trim();
+    if (!normalized) {
+      if (!this.slots.delete(key)) return false;
+      return true;
+    }
+    if (this.slots.get(key) === normalized) return false;
+    this.slots.set(key, normalized);
+    return true;
+  }
+  clear() {
+    this.slots.clear();
+  }
+  /** Render-ready suffix for the footer line, e.g. " · git:clean · ci:ok". */
+  format(maxWidth = 60) {
+    if (this.slots.size === 0) return "";
+    const joined = [...this.slots.values()].join(" \xB7 ");
+    return ` \xB7 ${truncateToWidth(joined, maxWidth, "")}`;
+  }
+};
+
 // src/components/footer.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var SPINNER_INTERVAL = 80;
@@ -67056,6 +67946,8 @@ var FooterComponent = class {
   spinnerFrame = 0;
   spinnerTimer = null;
   onRequestRender;
+  /** Keyed ambient status slots for extensions (ctx.ui.setStatus). */
+  extensionStatuses = new ExtensionStatusSlots();
   /** Set callback to request re-render when animation updates (pass true to force) */
   setOnRequestRender(callback) {
     this.onRequestRender = () => callback(true);
@@ -67168,6 +68060,7 @@ var FooterComponent = class {
     const statusWithSpinner = spinner ? `${spinner} ${statusText}` : statusText;
     statsParts.push(theme.fg(statusColor[state.status], statusWithSpinner));
     let statsLeft = statsParts.join(" ");
+    statsLeft += this.extensionStatuses.format();
     const modelName = state.modelName || "no-model";
     let rightSide = modelName;
     if (state.thinkingLevel && state.thinkingLevel !== "off") {
@@ -67223,9 +68116,11 @@ var TodoWidgetComponent = class extends Container {
 
 // src/agent-guidelines.ts
 function buildCodingAgentGuidelinesSection(tools = []) {
-  void tools;
+  const hasTodoTool = tools.some((tool) => tool.name === "manage_todo_list");
   const guidelines = [
     "Handle coding tasks by analyzing, planning, or making changes as the available tools and user request allow; do not stop at analysis when execution is expected.",
+    `Keep going until the user's task is completely resolved before ending your turn. If you announce a next step (for example, "now run the tests"), execute it in the same turn instead of describing it; only end your turn when the task is done or you genuinely need user input.`,
+    ...hasTodoTool ? ["For multi-step tasks, set up progress tracking with manage_todo_list before starting, and keep exactly one step in progress until every step is complete."] : [],
     "Work in the current workspace, preserve user changes, and keep edits focused.",
     "Inspect the relevant code before changing it. Use file tools for workspace writes; do not use shell redirection or heredocs to bypass write_file/edit_file guards.",
     "Run the most relevant existing test, build, or check after file changes when practical.",
@@ -67503,6 +68398,9 @@ function setupUI(host) {
   host.todoWidgetContainer = new Container();
   host.todoWidget = new TodoWidgetComponent(host.executionState);
   host.todoWidgetContainer.addChild(host.todoWidget);
+  host.extensionWidgetsContainer = new Container();
+  host.extensionWidgets = new ExtensionWidgetsComponent();
+  host.extensionWidgetsContainer.addChild(host.extensionWidgets);
   const editorTheme = getEditorTheme();
   host.editor = new Editor(host.ui, editorTheme, { paddingX: 1 });
   host.editor.onChange = () => {
@@ -67517,6 +68415,7 @@ function setupUI(host) {
   host.ui.addChild(host.chatContainer);
   host.ui.addChild(host.pendingMessagesContainer);
   host.ui.addChild(host.todoWidgetContainer);
+  host.ui.addChild(host.extensionWidgetsContainer);
   host.ui.addChild(new Spacer());
   host.ui.addChild(host.footer);
   host.ui.addChild(host.editorContainer);
@@ -67846,11 +68745,11 @@ var HierarchicalSelectorComponent = class extends Container {
 // src/runtime/interactive-ui-helpers.ts
 function showHierarchicalMenu(host, initialPath = []) {
   const basePath = [...initialPath];
-  const showAtPath = (path31) => {
+  const showAtPath = (path33) => {
     host.showSelector((done) => {
       const selector = new HierarchicalSelectorComponent({
         tree: commandTree,
-        path: path31,
+        path: path33,
         basePath,
         onNavigate: (newPath) => {
           done();
@@ -67858,7 +68757,7 @@ function showHierarchicalMenu(host, initialPath = []) {
         },
         onSelect: async (selectedPath, node, searchArgs) => {
           if (node.handler) {
-            const args = searchArgs || (selectedPath.length > path31.length ? selectedPath.slice(path31.length).join(" ") : void 0);
+            const args = searchArgs || (selectedPath.length > path33.length ? selectedPath.slice(path33.length).join(" ") : void 0);
             const commandPath = "/" + selectedPath.join("/");
             if (!args && host.isInteractiveCommand(commandPath)) {
               done();
@@ -67952,10 +68851,17 @@ function getContinuationTimeoutMs() {
   if (Number.isFinite(raw) && raw > 0) return raw;
   return 2e4;
 }
+var STALL_RECHECK_MS = 1e3;
+function getHardStallTimeoutMs() {
+  const raw = Number(process.env.PIE_INTERACTIVE_HARD_STALL_TIMEOUT_MS || "");
+  if (Number.isFinite(raw) && raw > 0) return raw;
+  return 30 * 6e4;
+}
 function clearContinuationTimeout(host, reason) {
   if (!host.continuationTimeoutHandle) return;
   clearTimeout(host.continuationTimeoutHandle);
   host.continuationTimeoutHandle = void 0;
+  host.continuationStallSinceMs = void 0;
   host.logDebug("continuation_timeout:cleared", {
     reason,
     awaitingContinuation: host.executionState.read().awaitingContinuation
@@ -67988,6 +68894,36 @@ function appendWarningSummary(host, message) {
   host.chatContainer.addChild(new Spacer(1));
   host.safeRequestRender();
 }
+async function recoverHardStalledTurn(host, stalledMs) {
+  host.continuationStallSinceMs = void 0;
+  host.logDebug("continuation_timeout:hard_stall_recovery", { stalledMs });
+  host.agentSessionController?.abort();
+  try {
+    await Promise.race([
+      host.agentSessionController?.waitForIdle() ?? Promise.resolve(),
+      new Promise((resolve7) => setTimeout(resolve7, 2e3))
+    ]);
+  } catch (error) {
+    host.logDebug("continuation_timeout:hard_stall_wait_failed", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  host.agent.resetProcessingState();
+  host.isProcessing = false;
+  host.setSubmitLock(false);
+  host.streamingComponent = void 0;
+  host.pendingTools.clear();
+  const abortOutcome = host.executionState.abort();
+  host.persistExecutionState();
+  void host.refreshTodoWidget();
+  host.footer.setState({ status: "ready" });
+  host.safeRequestRender();
+  host.ringAttentionBell?.();
+  appendWarningSummary(host, "Recovered from a stalled turn (no progress for " + Math.round(stalledMs / 1e3) + "s). The previous turn was interrupted; review its partial output before continuing.");
+  if (abortOutcome.terminalSummary) {
+    appendWarningSummary(host, abortOutcome.terminalSummary);
+  }
+}
 function scheduleContinuationTimeout(host) {
   host.clearContinuationTimeout("reschedule");
   const timeoutMs = getContinuationTimeoutMs();
@@ -67996,23 +68932,38 @@ function scheduleContinuationTimeout(host) {
     currentStepId: host.executionState.read().currentStepId,
     queueLength: host.agentSessionController?.pendingMessageCount ?? 0
   });
-  host.continuationTimeoutHandle = setTimeout(() => {
+  const check = () => {
     host.continuationTimeoutHandle = void 0;
     const state = host.executionState.read();
     if (!state.awaitingContinuation || isWaitingForUserInteraction(host)) {
+      host.continuationStallSinceMs = void 0;
       host.logDebug("continuation_timeout:skip", {
         reason: !state.awaitingContinuation ? "no_longer_awaiting" : "waiting_for_user_interaction"
       });
       return;
     }
     if (host.agent.state.isStreaming || host.isProcessing || host.submitLock || host.pendingTools.size > 0) {
-      host.logDebug("continuation_timeout:active_work", {
-        isStreaming: host.agent.state.isStreaming,
-        isProcessing: host.isProcessing,
-        pendingTools: host.pendingTools.size
-      });
+      const now = Date.now();
+      const stallSince = host.continuationStallSinceMs ?? now;
+      host.continuationStallSinceMs = stallSince;
+      const stalledMs = now - stallSince;
+      const hardTimeoutMs = getHardStallTimeoutMs();
+      if (stalledMs < hardTimeoutMs) {
+        host.logDebug("continuation_timeout:active_work", {
+          isStreaming: host.agent.state.isStreaming,
+          isProcessing: host.isProcessing,
+          pendingTools: host.pendingTools.size,
+          stalledMs,
+          hardTimeoutMs
+        });
+        const nextCheckMs = Math.max(50, Math.min(STALL_RECHECK_MS, hardTimeoutMs - stalledMs));
+        host.continuationTimeoutHandle = setTimeout(check, nextCheckMs);
+        return;
+      }
+      void recoverHardStalledTurn(host, stalledMs);
       return;
     }
+    host.continuationStallSinceMs = void 0;
     const outcome = host.executionState.markAwaitingContinuationStalled();
     host.logDebug("continuation_timeout:expired", {
       currentStepId: state.currentStepId,
@@ -68028,7 +68979,8 @@ function scheduleContinuationTimeout(host) {
       }
     }
     host.agentSessionController?.requestQueueDispatch();
-  }, timeoutMs);
+  };
+  host.continuationTimeoutHandle = setTimeout(check, timeoutMs);
 }
 
 // src/runtime/interactive-controller-setup.ts
@@ -68094,12 +69046,29 @@ function createInteractiveAgentSessionController(host) {
       baseDelayMs: getCliRetryBaseDelayMs()
     },
     compaction: {
-      compact: async (context) => createCliAutoCompactionResult({
-        context,
-        model: host.options.model,
-        apiKey: host.options.apiKey,
-        systemPrompt: host.agent.state.systemPrompt
-      })
+      compact: async (context) => {
+        const beforeCompact = await host.extensionRunner?.emitSessionBeforeCompact({
+          type: "session:before_compact",
+          reason: context.reason === "overflow" ? "overflow" : "threshold",
+          messageCount: context.messages.length
+        });
+        if (beforeCompact?.cancel) {
+          host.showStatus("Auto-compaction cancelled by an extension");
+          return { aborted: true };
+        }
+        if (beforeCompact?.summary) {
+          const activeEntryId = context.sessionManager.getActiveEntryId();
+          const firstKeptEntryId = activeEntryId ? findFirstKeptEntryId(context.sessionManager.getPathToEntry(activeEntryId)) : void 0;
+          if (!firstKeptEntryId) return { aborted: true };
+          return { summary: beforeCompact.summary, firstKeptEntryId };
+        }
+        return createCliAutoCompactionResult({
+          context,
+          model: host.options.model,
+          apiKey: host.options.apiKey,
+          systemPrompt: host.agent.state.systemPrompt
+        });
+      }
     },
     onEvent: (event) => {
       host.sessionTrace.noteRuntimeEvent(event.type, event);
@@ -68168,6 +69137,7 @@ function createInteractiveAgentSessionController(host) {
           host.appendWarningSummary(outcome.terminalSummary);
         }
         host.sessionTrace.completeTurn(event.message, false);
+        ringTurnSettledBell(host);
         host._semanticTurnIndex++;
       } else if (event.type === "turn_settled") {
         host.setControllerBusy(false);
@@ -68205,6 +69175,7 @@ function createInteractiveAgentSessionController(host) {
           host.showStatus("Todo list preserved. Send 'continue' when you want to resume it.");
         }
         host.showError(event.failure.message);
+        host.ringAttentionBell?.();
         host.setControllerBusy(false);
       } else if (event.type === "turn_cancelled") {
         const outcome = host.executionState.abort();
@@ -68533,7 +69504,7 @@ async function handleDirectBash(host, command) {
   child.stderr.on("data", (data) => {
     output.append(data.toString());
   });
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let settled = false;
     const finish = (code) => {
       if (settled) return;
@@ -68546,7 +69517,7 @@ async function handleDirectBash(host, command) {
       }
       host.chatContainer.addChild(new Spacer(1));
       host.ui.requestRender();
-      resolve6();
+      resolve7();
     };
     child.on("error", (error) => {
       output.append(error.message);
@@ -68566,7 +69537,15 @@ function createInteractiveExtensionUIContext(host) {
     confirm: (title, message, opts) => showExtensionConfirm(host, title, message, opts),
     input: (title, placeholder, opts) => showExtensionInput(host, title, placeholder, opts),
     editor: (title, prefill) => showExtensionEditor(host, title, prefill),
-    custom: (factory, options) => showExtensionCustom(host, factory, options)
+    custom: (factory, options) => showExtensionCustom(host, factory, options),
+    setStatus: (key, text) => {
+      host.footer.extensionStatuses.set(key, text);
+      host.ui.requestRender();
+    },
+    setWidget: (key, lines) => {
+      host.extensionWidgets.setWidget(key, lines);
+      host.ui.requestRender();
+    }
   };
 }
 function installInteractiveInteractionHandler(host) {
@@ -68575,6 +69554,7 @@ function installInteractiveInteractionHandler(host) {
       host.activeInteractionCount++;
       host.setWaitingForUser(true);
       host.footer.setState({ lifecycleEvent: "waiting_for_user_input" });
+      host.ringAttentionBell?.();
       host.safeRequestRender();
     };
     const endWaitingForUser = () => {
@@ -68585,15 +69565,15 @@ function installInteractiveInteractionHandler(host) {
       host.footer.setState({ lifecycleEvent: "tool_execution_start" });
       host.safeRequestRender();
     };
-    const withTimeout = async (promise) => {
+    const withTimeout2 = async (promise) => {
       if (!("timeoutMs" in request) || !request.timeoutMs || request.timeoutMs <= 0) {
         return { value: await promise, timedOut: false };
       }
-      return await new Promise((resolve6, reject) => {
-        const timer = setTimeout(() => resolve6({ timedOut: true }), request.timeoutMs);
+      return await new Promise((resolve7, reject) => {
+        const timer = setTimeout(() => resolve7({ timedOut: true }), request.timeoutMs);
         promise.then((value) => {
           clearTimeout(timer);
-          resolve6({ value, timedOut: false });
+          resolve7({ value, timedOut: false });
         }).catch((error) => {
           clearTimeout(timer);
           reject(error);
@@ -68603,7 +69583,7 @@ function installInteractiveInteractionHandler(host) {
     const waitForUser = async (createPromise) => {
       beginWaitingForUser();
       try {
-        return await withTimeout(createPromise());
+        return await withTimeout2(createPromise());
       } finally {
         endWaitingForUser();
       }
@@ -68693,15 +69673,15 @@ function showExtensionNotification(host, message, type = "info") {
   host.ui.requestRender();
 }
 function showExtensionSelector2(host, title, options, opts) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     host.showStatus(`Waiting for selection: ${title}`);
     if (opts?.signal?.aborted) {
-      resolve6(void 0);
+      resolve7(void 0);
       return;
     }
     const onAbort = () => {
       host.restoreEditor();
-      resolve6(void 0);
+      resolve7(void 0);
     };
     opts?.signal?.addEventListener("abort", onAbort, { once: true });
     const selector = new ExtensionSelectorComponent(
@@ -68710,12 +69690,12 @@ function showExtensionSelector2(host, title, options, opts) {
       (option) => {
         opts?.signal?.removeEventListener("abort", onAbort);
         host.restoreEditor();
-        resolve6(option);
+        resolve7(option);
       },
       () => {
         opts?.signal?.removeEventListener("abort", onAbort);
         host.restoreEditor();
-        resolve6(void 0);
+        resolve7(void 0);
       }
     );
     host.editorContainer.clear();
@@ -68731,15 +69711,15 @@ ${message}`, ["Yes", "No"], opts);
   return result === "Yes";
 }
 function showExtensionInput(host, title, placeholder, opts) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     host.showStatus(`Waiting for input: ${title}`);
     if (opts?.signal?.aborted) {
-      resolve6(void 0);
+      resolve7(void 0);
       return;
     }
     const onAbort = () => {
       host.restoreEditor();
-      resolve6(void 0);
+      resolve7(void 0);
     };
     opts?.signal?.addEventListener("abort", onAbort, { once: true });
     const input = new ExtensionInputComponent(
@@ -68748,12 +69728,12 @@ function showExtensionInput(host, title, placeholder, opts) {
       (value) => {
         opts?.signal?.removeEventListener("abort", onAbort);
         host.restoreEditor();
-        resolve6(value);
+        resolve7(value);
       },
       () => {
         opts?.signal?.removeEventListener("abort", onAbort);
         host.restoreEditor();
-        resolve6(void 0);
+        resolve7(void 0);
       }
     );
     host.editorContainer.clear();
@@ -68764,7 +69744,7 @@ function showExtensionInput(host, title, placeholder, opts) {
   });
 }
 function showExtensionEditor(host, title, prefill) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     host.showStatus(`Waiting for input: ${title}`);
     const container = new Container();
     container.addChild(new Text(theme.bold(theme.fg("accent", title)), 0, 0));
@@ -68786,12 +69766,12 @@ function showExtensionEditor(host, title, prefill) {
         preview: value.slice(0, 120)
       });
       host.restoreEditor();
-      resolve6(value);
+      resolve7(value);
     };
     editor.onEscape = () => {
       host.logDebug("extension:editor:cancel", { title });
       host.restoreEditor();
-      resolve6(void 0);
+      resolve7(void 0);
     };
     container.addChild(editor);
     container.addChild(new Spacer(1));
@@ -68805,14 +69785,14 @@ function showExtensionEditor(host, title, prefill) {
 }
 function showExtensionCustom(host, factory, options) {
   const savedText = host.editor.getText();
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     let closed = false;
     const close = (result) => {
       if (closed) return;
       closed = true;
       host.restoreEditor();
       host.editor.setText(savedText);
-      resolve6(result);
+      resolve7(result);
     };
     Promise.resolve(factory(host.ui, theme, close)).then((component) => {
       if (closed) return;
@@ -68833,6 +69813,60 @@ function showExtensionCustom(host, factory, options) {
   });
 }
 
+// src/extensions/provider-login.ts
+var inFlightLogins = /* @__PURE__ */ new Map();
+async function loginExtensionProvider(options) {
+  const { provider } = options;
+  const existing = inFlightLogins.get(provider);
+  if (existing) return existing;
+  const attempt = runExtensionProviderLogin(options).finally(() => {
+    if (inFlightLogins.get(provider) === attempt) inFlightLogins.delete(provider);
+  });
+  inFlightLogins.set(provider, attempt);
+  return attempt;
+}
+async function runExtensionProviderLogin(options) {
+  const { provider, modelRegistry, authStorage, requestInteraction: requestInteraction2 } = options;
+  const oauth = modelRegistry.getExtensionOAuth(provider);
+  if (!oauth) return false;
+  const credentials = await oauth.login({
+    onAuth: ({ url }) => {
+      void requestInteraction2({
+        type: "notify",
+        message: `${oauth.name}: open this URL to sign in:
+${url}`,
+        level: "info"
+      });
+    },
+    onPrompt: async ({ message, placeholder }) => {
+      const response = await requestInteraction2({
+        type: "text_input",
+        id: `oauth:${provider}`,
+        prompt: `${oauth.name}: ${message}`,
+        placeholder
+      });
+      if (response.type !== "text_input" || response.timedOut || response.skipped || response.value === void 0) {
+        throw new Error(`${oauth.name} login cancelled.`);
+      }
+      return response.value;
+    }
+  });
+  authStorage.setOAuthCredentials(provider, credentials);
+  authStorage.setRuntimeApiKey(provider, credentials.access);
+  const errors = authStorage.drainErrors();
+  if (errors.length > 0) {
+    throw new Error(`Failed to persist ${oauth.name} credentials: ${errors[0].message}`);
+  }
+  return true;
+}
+async function restoreExtensionProviderCredentials(modelRegistry) {
+  for (const result of await modelRegistry.restorePersistedOAuth()) {
+    if (process.env.PIE_VERBOSE) {
+      console.error(`[Extension] OAuth restore ${result.provider}: ${result.action}${result.detail ? ` (${result.detail})` : ""}`);
+    }
+  }
+}
+
 // src/attachments/resolver.ts
 var AttachmentResolver = class {
   constructor(extensions) {
@@ -68996,6 +70030,26 @@ async function loadInteractiveExtensions(host) {
       activeSession.metadata[key] = value;
       activeSession.isDirty = true;
     },
+    appendEntry: (customType, data) => host.sessionManager.appendCustomEntry(customType, data).id,
+    setLabel: (entryId, label) => host.sessionManager.setLabel(entryId, label),
+    setSessionName: (name) => host.sessionManager.setSessionName(name),
+    getSessionName: () => host.sessionManager.getSessionName(),
+    registerProvider: (name, config) => {
+      const unregister = host.options.modelRegistry.registerProvider(name, config);
+      host.noteRuntimeModeChanged("extension_register_provider");
+      return unregister;
+    },
+    loginProvider: async (name) => {
+      const loggedIn = await loginExtensionProvider({
+        provider: name,
+        modelRegistry: host.options.modelRegistry,
+        authStorage: host.options.modelRegistry.getAuthStorage(),
+        requestInteraction
+      });
+      if (loggedIn) host.noteRuntimeModeChanged("extension_login_provider");
+      return loggedIn;
+    },
+    reload: () => host.reloadRuntime(),
     get yoloMode() {
       return host.yoloMode;
     }
@@ -69023,9 +70077,10 @@ async function loadInteractiveExtensions(host) {
     true
   );
   host.extensionRunner.setUIContext(host.extensionUIContext);
+  await restoreExtensionProviderCredentials(host.options.modelRegistry);
   if (process.env.PIE_VERBOSE) {
-    for (const { path: path31, error } of errors) {
-      console.error(`[Extension] Failed to load ${path31}: ${error}`);
+    for (const { path: path33, error } of errors) {
+      console.error(`[Extension] Failed to load ${path33}: ${error}`);
     }
   }
   const extensionTools = convertExtensionTools(extensions);
@@ -69079,6 +70134,8 @@ var InteractiveMode = class {
   editorContainer;
   todoWidgetContainer;
   todoWidget;
+  extensionWidgetsContainer;
+  extensionWidgets;
   executionState = new ExecutionStateManager();
   sessionTrace;
   keybindings;
@@ -69143,10 +70200,24 @@ var InteractiveMode = class {
   lastStatusText;
   lastSigintTime = 0;
   continuationTimeoutHandle;
+  continuationStallSinceMs;
   activeInteractionCount = 0;
   logDebug(message, data) {
     fileLogger.log("interactive", message, data);
   }
+  /** Streams and tool updates prove the turn is alive; restart the no-progress clock. */
+  noteContinuationActivity() {
+    this.continuationStallSinceMs = void 0;
+  }
+  /**
+   * Ring the terminal bell (BEL) when a turn needs the user's attention:
+   * interaction prompts, turn completion/failure, and stall recovery. The
+   * bell itself enforces a cross-call-site cooldown; the settings gate here
+   * is the single opt-out point (settings.json `notifications.bell`).
+   */
+  ringAttentionBell() {
+    ringTerminalBell({ enabled: this.options.settingsManager.getBellNotificationsEnabled() });
+  }
   getContinuationTimeoutMs() {
     return getContinuationTimeoutMs();
   }
@@ -69389,7 +70460,7 @@ var InteractiveMode = class {
     if (savedLevel) {
       this.thinkingLevel = savedLevel;
     }
-    const { Agent } = await import("./chunks/src-NHRMBQAJ.js");
+    const { Agent } = await import("./chunks/src-TQNFXZGK.js");
     const activeSession = this.sessionManager.getActiveSession();
     this.agent = new Agent({
       initialState: {
@@ -69480,6 +70551,40 @@ var InteractiveMode = class {
     installInteractiveInteractionHandler(this);
     await loadInteractiveExtensions(this.extensionLoaderHost);
   }
+  /**
+   * Full runtime reload (extension API `ctx.reload()`): re-discover skills
+   * and extensions from disk and rebuild the tool surface and system prompt.
+   * Rejects while a turn is processing. Listener lifecycle contract: the old
+   * extension instances are dropped entirely (handlers, tools, commands),
+   * the tool surface is reset to the pristine composition baseline, and the
+   * fresh ExtensionRunner re-wraps from that baseline — no stale handlers
+   * and no double-wrapped tools survive a reload.
+   */
+  async reloadRuntime() {
+    if (this.isProcessing) {
+      throw new Error("Cannot reload while a response is being processed. Wait for the turn to finish or abort it first.");
+    }
+    const builtinDir = path29.join(getBuiltinDir(), "skills");
+    const userDir = path29.join(os8.homedir(), ".pie", "skills");
+    const projectDir = path29.join(this.options.cwd, ".pie", "skills");
+    const { skills, diagnostics } = loadSkills({
+      dirs: buildSkillDirs({ builtinDir, userDir, projectDir, cwd: this.options.cwd })
+    });
+    this.skills = skills;
+    this.skillsSection = formatSkillsForPrompt(skills);
+    for (const diag of diagnostics.filter((entry) => entry.type === "collision")) {
+      this.chatContainer.addChild(new Text(theme.fg("dim", `[reload] ${diag.message}`), 1, 0));
+    }
+    this.allTools = [...this.options.allTools];
+    this.originalTools = [...this.options.allTools];
+    this.agent.state.tools = [...this.options.allTools];
+    this.extensionRunner?.revokeRegistrations();
+    this.extensionWidgets?.clearAll();
+    await this.loadExtensions();
+    this.applyRuntimeToolMode();
+    this.noteRuntimeModeChanged("extension_reload");
+    this.ui.requestRender();
+  }
   calculateContextUsage() {
     return calculateContextUsage(this.contextUiHost);
   }
@@ -69728,8 +70833,8 @@ var InteractiveMode = class {
 };
 
 // src/app/runtime-composition.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync12 } from "fs";
-import * as path28 from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync13 } from "fs";
+import * as path30 from "path";
 var CliMissingApiKeyError = class extends Error {
   constructor(message) {
     super(message);
@@ -69750,13 +70855,13 @@ var CliSessionResumeError = class extends Error {
 function getCliRuntimePaths() {
   const configDir = getConfigDir();
   const sessionsDir = getSessionsDir();
-  const skillsDir = path28.join(configDir, "skills");
-  const builtinSkillsDir = path28.join(getBuiltinDir(), "skills");
+  const skillsDir = path30.join(configDir, "skills");
+  const builtinSkillsDir = path30.join(getBuiltinDir(), "skills");
   return { configDir, sessionsDir, skillsDir, builtinSkillsDir };
 }
 function ensureCliRuntimePaths(paths = getCliRuntimePaths()) {
-  if (!existsSync17(paths.skillsDir)) {
-    mkdirSync12(paths.skillsDir, { recursive: true });
+  if (!existsSync18(paths.skillsDir)) {
+    mkdirSync13(paths.skillsDir, { recursive: true });
   }
   return paths;
 }
@@ -69782,7 +70887,7 @@ async function composeCliRuntime(params) {
   const paths = ensureCliRuntimePaths(params.paths);
   const compositionTrace = createCliCompositionTrace();
   const settingsManager = new SettingsManager();
-  const authStorage = new AuthStorage();
+  const authStorage = AuthStorage.fromStorage(new FileAuthStorageBackend());
   authStorage.setLegacyApiKey(settingsManager.getLegacyApiKey());
   const modelRegistry = new ModelRegistry(authStorage);
   await modelRegistry.refreshRemoteCatalogs();
@@ -69868,11 +70973,14 @@ async function composeCliRuntime(params) {
   fileLogger.log("cli", `Using API key for provider ${provider}`, {
     keyPrefix: apiKey ? maskApiKey2(apiKey) : "none"
   });
-  const projectSkillsDir = path28.join(cwd, ".pie", "skills");
+  const projectSkillsDir = path30.join(cwd, ".pie", "skills");
   const { skills, diagnostics } = loadSkills({
-    builtinDir: paths.builtinSkillsDir,
-    userDir: paths.skillsDir,
-    projectDir: projectSkillsDir
+    dirs: buildSkillDirs({
+      builtinDir: paths.builtinSkillsDir,
+      userDir: paths.skillsDir,
+      projectDir: projectSkillsDir,
+      cwd
+    })
   });
   let interactiveOptions;
   const getCurrentModel = () => interactiveOptions?.model ?? model;
@@ -70063,6 +71171,17 @@ async function loadPrintModeExtensions(params) {
       session.metadata[key] = value;
       session.isDirty = true;
     },
+    appendEntry: (customType, data) => params.sessionManager.appendCustomEntry(customType, data).id,
+    setLabel: (entryId, label) => params.sessionManager.setLabel(entryId, label),
+    setSessionName: (name) => params.sessionManager.setSessionName(name),
+    getSessionName: () => params.sessionManager.getSessionName(),
+    registerProvider: (name, config) => params.modelRegistry.registerProvider(name, config),
+    loginProvider: (name) => loginExtensionProvider({
+      provider: name,
+      modelRegistry: params.modelRegistry,
+      authStorage: params.modelRegistry.getAuthStorage(),
+      requestInteraction
+    }),
     yoloMode: false
   };
   const { extensions } = await loadExtensions(
@@ -70085,6 +71204,7 @@ async function loadPrintModeExtensions(params) {
     false
   );
   runner.setUIContext(uiContext);
+  await restoreExtensionProviderCredentials(params.modelRegistry);
   const extensionTools = convertExtensionTools(extensions);
   availableTools = [...availableTools, ...extensionTools];
   return {
@@ -70110,7 +71230,7 @@ async function runPrintMode(params) {
 `);
     console.log("Assistant: ");
   }
-  const { Agent: AgentClass } = await import("./chunks/src-NHRMBQAJ.js");
+  const { Agent: AgentClass } = await import("./chunks/src-TQNFXZGK.js");
   let agent;
   const printModeExtensions = await loadPrintModeExtensions({
     cwd: runtime.cwd,
@@ -70126,6 +71246,8 @@ async function runPrintMode(params) {
     allTools: runtime.allTools
   });
   const printModeTools = [...runtime.tools, ...printModeExtensions.extensionTools];
+  const restoredApiKey = runtime.modelRegistry.getApiKey(runtime.model);
+  if (restoredApiKey) runtime.apiKey = restoredApiKey;
   recordCliCompositionStep(runtime.compositionTrace, {
     id: "extensions_tool_wrapping",
     inputSummary: `baseTools=${runtime.tools.length} extensionPaths=${runtime.extensionPaths.length}`,
@@ -70189,12 +71311,26 @@ async function runPrintMode(params) {
       isContextOverflowError: isCliContextOverflowError
     }),
     compaction: {
-      compact: async (context) => createCliAutoCompactionResult({
-        context,
-        model: runtime.model,
-        apiKey: runtime.apiKey,
-        systemPrompt: agent?.state.systemPrompt ?? baseSystemPrompt
-      })
+      compact: async (context) => {
+        const beforeCompact = await printModeExtensions.runner.emitSessionBeforeCompact({
+          type: "session:before_compact",
+          reason: context.reason === "overflow" ? "overflow" : "threshold",
+          messageCount: context.messages.length
+        });
+        if (beforeCompact.cancel) return { aborted: true };
+        if (beforeCompact.summary) {
+          const activeEntryId = context.sessionManager.getActiveEntryId();
+          const firstKeptEntryId = activeEntryId ? findFirstKeptEntryId(context.sessionManager.getPathToEntry(activeEntryId)) : void 0;
+          if (!firstKeptEntryId) return { aborted: true };
+          return { summary: beforeCompact.summary, firstKeptEntryId };
+        }
+        return createCliAutoCompactionResult({
+          context,
+          model: runtime.model,
+          apiKey: runtime.apiKey,
+          systemPrompt: agent?.state.systemPrompt ?? baseSystemPrompt
+        });
+      }
     },
     classifyFailure: (context) => classifyCliFailure(context),
     onEvent: (event) => {
@@ -70516,6 +71652,7 @@ async function loadJsonModeExtensions(params) {
     false
   );
   runner.setUIContext(uiContext);
+  await restoreExtensionProviderCredentials(params.runtime.modelRegistry);
   const extensionTools = convertExtensionTools(extensions);
   availableTools = [...availableTools, ...extensionTools];
   return {
@@ -70549,7 +71686,7 @@ async function runJsonEventsMode(params) {
     return typeof message.sessionId === "string" && message.sessionId !== sessionId;
   }
   function delay(ms) {
-    return new Promise((resolve6) => setTimeout(resolve6, Math.max(0, ms)));
+    return new Promise((resolve7) => setTimeout(resolve7, Math.max(0, ms)));
   }
   async function waitForActiveController(timeoutMs = 1e3) {
     const deadline = Date.now() + timeoutMs;
@@ -71060,9 +72197,11 @@ async function runJsonEventsMode(params) {
     if (runtime.initialModel.unconfigured || controller) {
       return;
     }
-    const { Agent: AgentClass } = await import("./chunks/src-NHRMBQAJ.js");
+    const { Agent: AgentClass } = await import("./chunks/src-TQNFXZGK.js");
     const jsonModeExtensions = await loadJsonModeExtensions({ runtime, getAgent: () => agent });
     const tools = [...runtime.tools, ...jsonModeExtensions.extensionTools];
+    const restoredApiKey = runtime.modelRegistry.getApiKey(runtime.model);
+    if (restoredApiKey) runtime.apiKey = restoredApiKey;
     recordCliCompositionStep(runtime.compositionTrace, {
       id: "extensions_tool_wrapping",
       inputSummary: `baseTools=${runtime.tools.length} extensionPaths=${runtime.extensionPaths.length}`,
@@ -71494,19 +72633,19 @@ async function runJsonEventsMode(params) {
 }
 
 // src/developer-instructions.ts
-import * as fs26 from "fs";
-import * as path29 from "path";
+import * as fs27 from "fs";
+import * as path31 from "path";
 var MAX_DEVELOPER_INSTRUCTIONS_CHARS = 64e3;
 function readTextFileBounded(filePath) {
-  const resolved = path29.resolve(filePath);
-  const stat2 = fs26.statSync(resolved);
+  const resolved = path31.resolve(filePath);
+  const stat2 = fs27.statSync(resolved);
   if (!stat2.isFile()) {
     throw new Error(`Developer instructions file is not a regular file: ${filePath}`);
   }
   if (stat2.size > MAX_DEVELOPER_INSTRUCTIONS_CHARS * 4) {
     throw new Error(`Developer instructions file is too large: ${filePath}`);
   }
-  return fs26.readFileSync(resolved, "utf8");
+  return fs27.readFileSync(resolved, "utf8");
 }
 function collectFlagValues(args, flag) {
   const values = [];
@@ -71584,8 +72723,8 @@ var logError = (msg, err) => {
   const logPath = getRuntimeLogPath();
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const stack = err instanceof Error ? err.stack || "" : "";
-  fs27.mkdirSync(path30.dirname(logPath), { recursive: true });
-  fs27.appendFileSync(logPath, `[${timestamp}] ${msg}
+  fs28.mkdirSync(path32.dirname(logPath), { recursive: true });
+  fs28.appendFileSync(logPath, `[${timestamp}] ${msg}
 ${stack}
 
 `);
@@ -71692,7 +72831,7 @@ async function runWithJsonEventsConsoleIsolation(fn) {
 }
 async function createCliTestStreamFnFromEnv() {
   if (!process.env.PIE_TEST_MOCK_STREAM_SEQUENCE) return void 0;
-  return (await import("./chunks/test-stream-I6S23PTW.js")).createTestStreamFnFromSequenceEnv();
+  return (await import("./chunks/test-stream-IPBFEEWH.js")).createTestStreamFnFromSequenceEnv();
 }
 async function startChat(initialPrompt, testCommand) {
   const rawOutput = process.argv.includes("--raw-output");
@@ -71787,9 +72926,9 @@ async function startChat(initialPrompt, testCommand) {
     flushEarlyLogs();
     if (testCommand) {
       console.log(`[TEST] Auto-executing command: ${testCommand}`);
-      await new Promise((resolve6) => setTimeout(resolve6, 500));
+      await new Promise((resolve7) => setTimeout(resolve7, 500));
       await interactive.executeCommand(testCommand);
-      await new Promise((resolve6) => setTimeout(resolve6, 2e3));
+      await new Promise((resolve7) => setTimeout(resolve7, 2e3));
       console.log("[TEST] Command executed, exiting...");
       process.exit(0);
       return;