claudish 7.24.0 → 7.26.0

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.24.0";
+var VERSION = "7.26.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -1173,6 +1173,122 @@ var init_startup_trace = __esm(() => {
   spans = [];
 });
 
+// src/providers/onepassword-handshake-lock.ts
+import { closeSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync3, rmSync, statSync, writeSync } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
+function defaultLockPath() {
+  return join4(homedir4(), ".claudish", "op-handshake.lock");
+}
+function currentLockPath() {
+  return lockPath ?? defaultLockPath();
+}
+function trace(message) {
+  if (process.env.CLAUDISH_OP_LOCK_TRACE !== "1")
+    return;
+  console.error(`[op-lock] pid=${process.pid} ${message}`);
+}
+function readHolder(path) {
+  try {
+    const [pidRaw, atRaw] = readFileSync3(path, "utf-8").trim().split(/\s+/);
+    const pid = Number(pidRaw);
+    const at = Number(atRaw);
+    if (!Number.isInteger(pid) || pid <= 0)
+      return null;
+    return { pid, at: Number.isFinite(at) ? at : 0 };
+  } catch {
+    return null;
+  }
+}
+function holderAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err?.code === "EPERM";
+  }
+}
+function isAbandoned(path) {
+  const holder = readHolder(path);
+  if (!holder) {
+    try {
+      return Date.now() - statSync(path).mtimeMs > timing.staleMs;
+    } catch {
+      return false;
+    }
+  }
+  if (holder.pid !== process.pid && !holderAlive(holder.pid))
+    return true;
+  return Date.now() - holder.at > timing.staleMs;
+}
+async function acquire(path) {
+  const deadline = Date.now() + timing.timeoutMs;
+  let madeDir = false;
+  for (;; ) {
+    try {
+      if (!madeDir) {
+        mkdirSync3(dirname2(path), { recursive: true });
+        madeDir = true;
+      }
+      const fd = openSync(path, "wx");
+      try {
+        writeSync(fd, `${process.pid} ${Date.now()}`);
+      } finally {
+        closeSync(fd);
+      }
+      return true;
+    } catch (err) {
+      if (err?.code !== "EEXIST")
+        return false;
+      if (isAbandoned(path)) {
+        try {
+          rmSync(path, { force: true });
+        } catch {}
+        continue;
+      }
+      if (Date.now() >= deadline)
+        return false;
+      await sleep(timing.pollMs + Math.floor(Math.random() * timing.pollMs));
+    }
+  }
+}
+function release(path) {
+  try {
+    if (readHolder(path)?.pid === process.pid)
+      rmSync(path, { force: true });
+  } catch {}
+}
+async function withHandshakeLock(handshake) {
+  if (process.env.CLAUDISH_NO_OP_HANDSHAKE_LOCK === "1") {
+    trace("bypassed (CLAUDISH_NO_OP_HANDSHAKE_LOCK=1)");
+    return handshake();
+  }
+  const path = currentLockPath();
+  const t0 = Date.now();
+  let held = false;
+  try {
+    held = await acquire(path);
+  } catch {
+    held = false;
+  }
+  trace(`${held ? "acquired" : "NOT held (timeout or unwritable)"} after ${Date.now() - t0}ms`);
+  try {
+    return await handshake();
+  } finally {
+    if (held)
+      release(path);
+    trace(`handshake done after ${Date.now() - t0}ms${held ? ", released" : ""}`);
+  }
+}
+var DEFAULT_STALE_MS = 120000, DEFAULT_TIMEOUT_MS = 45000, DEFAULT_POLL_MS = 60, timing, lockPath, sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var init_onepassword_handshake_lock = __esm(() => {
+  timing = {
+    staleMs: DEFAULT_STALE_MS,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    pollMs: DEFAULT_POLL_MS
+  };
+});
+
 // src/providers/onepassword-wasm.ts
 var exports_onepassword_wasm = {};
 __export(exports_onepassword_wasm, {
@@ -1185,17 +1301,17 @@ __export(exports_onepassword_wasm, {
   SDK_CORE_INTEGRITY: () => SDK_CORE_INTEGRITY
 });
 import { createHash } from "crypto";
-import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { copyFileSync, existsSync as existsSync3, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname2, join as join4 } from "path";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname3, join as join5 } from "path";
 import { gunzipSync } from "zlib";
 function tarballUrl() {
   return `https://registry.npmjs.org/@1password/sdk-core/-/sdk-core-${SDK_CORE_VERSION}.tgz`;
 }
 function cacheWasmPath() {
-  const root = cacheRootOverride ?? join4(homedir4(), ".claudish");
-  return join4(root, "cache", "1password", WASM_FILENAME);
+  const root = cacheRootOverride ?? join5(homedir5(), ".claudish");
+  return join5(root, "cache", "1password", WASM_FILENAME);
 }
 function verifyIntegrity(bytes) {
   const [algo, expected] = SDK_CORE_INTEGRITY.split("-", 2);
@@ -1236,7 +1352,7 @@ function installReadFileSyncIntercept() {
       }
       if (existsSync3(path)) {
         try {
-          mkdirSync3(dirname2(cached), { recursive: true });
+          mkdirSync4(dirname3(cached), { recursive: true });
           copyFileSync(path, cached);
         } catch {}
       }
@@ -1259,7 +1375,7 @@ async function downloadAndCacheWasm() {
   if (!wasm) {
     throw new Error(`1Password runtime archive did not contain ${WASM_TARBALL_ENTRY}`);
   }
-  mkdirSync3(dirname2(cached), { recursive: true });
+  mkdirSync4(dirname3(cached), { recursive: true });
   const tmp = `${cached}.tmp`;
   writeFileSync4(tmp, wasm);
   createRequire(import.meta.url)("node:fs").renameSync(tmp, cached);
@@ -1292,7 +1408,7 @@ function resolveNearbyWasmPath() {
   try {
     const require2 = createRequire(import.meta.url);
     const coreJs = require2.resolve("@1password/sdk-core/nodejs/core.js");
-    const wasm = join4(dirname2(coreJs), WASM_FILENAME);
+    const wasm = join5(dirname3(coreJs), WASM_FILENAME);
     return existsSync3(wasm) ? wasm : null;
   } catch {
     return null;
@@ -1304,7 +1420,7 @@ function seedCacheFromNearbyWasm() {
     return false;
   try {
     const cached = cacheWasmPath();
-    mkdirSync3(dirname2(cached), { recursive: true });
+    mkdirSync4(dirname3(cached), { recursive: true });
     copyFileSync(real, cached);
     return true;
   } catch {
@@ -3658,6 +3774,7 @@ __export(exports_onepassword, {
   valueTail: () => valueTail,
   setScreenLockProbe: () => setScreenLockProbe,
   setLockRetryTiming: () => setLockRetryTiming,
+  setAppLockProbe: () => setAppLockProbe,
   resolveSecretsPartial: () => resolveSecretsPartial,
   resolveSecrets: () => resolveSecrets,
   resolveSdkAuth: () => resolveSdkAuth,
@@ -3682,6 +3799,7 @@ __export(exports_onepassword, {
   isOpHydratedVar: () => isOpHydratedVar,
   isLockedDenial: () => isLockedDenial,
   isGlobImport: () => isGlobImport,
+  isAppLocked: () => isAppLocked,
   globToRegExp: () => globToRegExp,
   getOpFailures: () => getOpFailures,
   filterGlobFields: () => filterGlobFields,
@@ -3692,8 +3810,12 @@ __export(exports_onepassword, {
   defaultSdkClientFactory: () => defaultSdkClientFactory,
   defaultScreenLockProbe: () => defaultScreenLockProbe,
   defaultOpAccountLister: () => defaultOpAccountLister,
+  defaultAppLockProbe: () => defaultAppLockProbe,
+  currentLockCause: () => currentLockCause,
   collectConfigImports: () => collectConfigImports,
+  classifyLockedDenial: () => classifyLockedDenial,
   buildAuthError: () => buildAuthError,
+  appLockedFromSettings: () => appLockedFromSettings,
   acquireSdkClient: () => acquireSdkClient,
   OP_REF_RE: () => OP_REF_RE
 });
@@ -3735,11 +3857,24 @@ function renderOpFailureNotice(envVar) {
   }
   lines.push("");
   if (wasOpAuthorizationDenied()) {
-    lines.push("  The 1Password desktop app declined to release secrets. This happens when");
-    lines.push("  the approval prompt was dismissed, or when your Mac is locked and the");
-    lines.push("  prompt cannot be shown at all.");
-    lines.push("");
-    lines.push("  Fix: unlock the Mac, approve the 1Password prompt, and re-run.");
+    const cause = currentLockCause();
+    if (cause === "screen") {
+      lines.push("  Your Mac is locked, so the 1Password approval prompt cannot be shown.");
+      lines.push("");
+      lines.push("  Fix: unlock the Mac, approve the prompt, and re-run.");
+    } else if (cause === "app") {
+      lines.push("  The 1Password app is LOCKED. With shared lock state (the default) a locked");
+      lines.push("  app refuses the SDK outright \u2014 no approval prompt is ever shown, which is");
+      lines.push("  why nothing appeared on screen.");
+      lines.push("");
+      lines.push("  Fix: unlock 1Password (Touch ID is enough) and re-run.");
+      lines.push("  To stop it re-locking mid-session, raise Settings \u2192 Security \u2192 auto-lock.");
+    } else {
+      lines.push("  The 1Password desktop app declined to release secrets. The approval prompt");
+      lines.push("  was most likely dismissed.");
+      lines.push("");
+      lines.push("  Fix: re-run and approve the 1Password prompt.");
+    }
     lines.push("  Headless (no desktop app): export OP_SERVICE_ACCOUNT_TOKEN='ops_...'");
   } else {
     lines.push("  Fix: check the reference resolves \u2014 claudish config \u2192 1Password tab.");
@@ -4092,25 +4227,57 @@ function setScreenLockProbe(probe) {
 function isScreenLocked() {
   return screenLockProbe();
 }
-function isLockedDenial(err, env = process.env) {
+function appLockedFromSettings(settings, nowSeconds) {
+  if (typeof settings !== "object" || settings === null)
+    return false;
+  const s = settings;
+  if (s["developers.sdkSharedLockState.enabled"] !== true)
+    return false;
+  const last = s["security.authenticatedUnlock.deviceBasedUnlock.lastUnlock"];
+  const after = s["security.authenticatedUnlock.deviceBasedUnlock.askUnlockAfter"];
+  if (typeof last !== "number" || typeof after !== "number")
+    return false;
+  return nowSeconds - last > after;
+}
+function setAppLockProbe(probe) {
+  appLockProbe = probe ?? defaultAppLockProbe;
+}
+function isAppLocked() {
+  return appLockProbe();
+}
+function currentLockCause() {
+  if (isScreenLocked())
+    return "screen";
+  if (isAppLocked())
+    return "app";
+  return null;
+}
+function classifyLockedDenial(err, env = process.env) {
   const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
   if (!msg.includes("denied authorization"))
-    return false;
+    return null;
   if (env.OP_SERVICE_ACCOUNT_TOKEN)
-    return false;
-  return isScreenLocked();
+    return null;
+  return currentLockCause();
+}
+function isLockedDenial(err, env = process.env) {
+  return classifyLockedDenial(err, env) !== null;
 }
-async function countdownForUnlock(round, rounds) {
+async function countdownForUnlock(round, rounds, cause) {
   const ttyOut = process.stderr.isTTY === true;
   const ttyIn = process.stdin.isTTY === true;
   let cancelled = false;
   if (round === 1) {
+    const explain = cause === "screen" ? `${bold("\uD83D\uDD10 1Password needs your OK \u2014 but your Mac is locked, so it can't ask.")}
+   Unlock your Mac and approve the popup. Claudish picks it up from there.` : `${bold("\uD83D\uDD10 1Password is locked, so it turned claudish away without asking you.")}
+   Unlock 1Password (Touch ID is enough). Claudish retries on its own \u2014
+   no popup will appear until it's unlocked.`;
     process.stderr.write(`
-${bold("\uD83D\uDD10 1Password needs your OK \u2014 but your Mac is locked, so it can't ask.")}
-   Unlock your Mac and approve the popup. Claudish picks it up from there.
+${explain}
 
 `);
   }
+  const stillLocked = () => cause === "screen" ? isScreenLocked() : isAppLocked();
   let restoreInput = () => {};
   if (ttyIn) {
     const onKey = (buf) => {
@@ -4141,7 +4308,7 @@ ${bold("\uD83D\uDD10 1Password needs your OK \u2014 but your Mac is locked, so i
     for (let remaining = lockRetrySeconds;remaining > 0; remaining--) {
       if (cancelled)
         break;
-      if (!isScreenLocked())
+      if (!stillLocked())
         break;
       if (ttyOut)
         process.stderr.write(`\r\x1B[2K${line(remaining)}`);
@@ -4164,9 +4331,10 @@ async function withSdkRetry(op, label = "op:sdk-op") {
     try {
       return await withSdkTransientRetry(op, label);
     } catch (err) {
-      if (round > LOCK_RETRY_ROUNDS || !isLockedDenial(err))
+      const cause = classifyLockedDenial(err);
+      if (round > LOCK_RETRY_ROUNDS || cause === null)
         throw err;
-      if (await countdownForUnlock(round, LOCK_RETRY_ROUNDS) === "cancel")
+      if (await countdownForUnlock(round, LOCK_RETRY_ROUNDS, cause) === "cancel")
         throw err;
       resetSdkClientCache();
     }
@@ -4359,11 +4527,12 @@ var OP_REF_RE, opHydratedVars, opSourceFailures, ENV_VAR_NAME_RE, sdkClientCache
       await ensureOpWasmAvailable2();
       return Promise.resolve().then(() => __toESM(require_sdk(), 1));
     });
-    const client = await traceSpan("op:client-handshake", () => createClient({
+    const build2 = () => createClient({
       auth: auth.kind === "token" ? auth.token : new DesktopAuth(auth.accountName),
       integrationName: "claudish",
       integrationVersion: VERSION || "1.0.0"
-    }), { mayIncludeUserPrompt: true, authKind: auth.kind });
+    });
+    const client = await traceSpan("op:client-handshake", () => auth.kind === "token" ? build2() : withHandshakeLock(build2), { mayIncludeUserPrompt: true, authKind: auth.kind });
     return client;
   })();
   sdkClientCache.set(key, build);
@@ -4383,7 +4552,7 @@ var OP_REF_RE, opHydratedVars, opSourceFailures, ENV_VAR_NAME_RE, sdkClientCache
   } catch {
     return false;
   }
-}, screenLockProbe, defaultOpAccountLister = () => {
+}, screenLockProbe, defaultAppLockProbe = () => false, appLockProbe, defaultOpAccountLister = () => {
   try {
     const res = spawnSync("op", ["account", "list", "--format=json"], { encoding: "utf-8" });
     if (res.error || res.status !== 0)
@@ -4412,6 +4581,7 @@ var OP_REF_RE, opHydratedVars, opSourceFailures, ENV_VAR_NAME_RE, sdkClientCache
 };
 var init_onepassword = __esm(() => {
   init_startup_trace();
+  init_onepassword_handshake_lock();
   OP_REF_RE = /^op:\/\/[^\s]+$/;
   opHydratedVars = new Set;
   opSourceFailures = [];
@@ -4420,18 +4590,34 @@ var init_onepassword = __esm(() => {
   sdkQueue = Promise.resolve();
   lockRetrySeconds = LOCK_RETRY_SECONDS;
   screenLockProbe = defaultScreenLockProbe;
+  appLockProbe = defaultAppLockProbe;
 });
 
 // src/auth/credentials/op-source.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join6 } from "path";
 function warnOnce(message) {
   if (warnedMessages.has(message))
     return;
   warnedMessages.add(message);
   console.error(message);
 }
+function recordOpUnavailableVars(names) {
+  for (const n of names) {
+    if (typeof n === "string" && n.length > 0)
+      opUnavailableVars.add(n);
+  }
+}
+function getOpUnavailableVars() {
+  return [...opUnavailableVars].sort();
+}
+function inheritedUnavailable() {
+  const raw = process.env[OP_UNAVAILABLE_ENV];
+  if (!raw)
+    return new Set;
+  return new Set(raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0));
+}
 function saveAccount(accountUrl, scope) {
   try {
     saveOnepasswordAccount(accountUrl, scope);
@@ -4517,10 +4703,10 @@ function readConfigRaw() {
   if (testSeams?.config)
     return testSeams.config;
   try {
-    const configPath = activeGlobalConfigFile(join5(homedir5(), ".claudish", "config.json"));
+    const configPath = activeGlobalConfigFile(join6(homedir6(), ".claudish", "config.json"));
     if (!existsSync4(configPath))
       return {};
-    return JSON.parse(readFileSync3(configPath, "utf-8"));
+    return JSON.parse(readFileSync4(configPath, "utf-8"));
   } catch {
     return {};
   }
@@ -4623,12 +4809,12 @@ async function resolveGlobShared(globPath, auth) {
     return { resolved: await existing, cacheHit: true };
   const spanName = `op:glob-resolve(${maskGlobForTrace(globPath)})`;
   const promise = (async () => {
-    const { resolveGlobImportAll: resolveGlobImportAll2, recordOpHydratedVars: recordOpHydratedVars2 } = await Promise.resolve().then(() => (init_onepassword(), exports_onepassword));
-    const resolved = await traceSpan(spanName, () => resolveGlobImportAll2(globPath, {
+    const { resolveGlobImportAll: resolveGlobImportAll2, recordOpHydratedVars: recordOpHydratedVars2, withSdkRetry: withSdkRetry2 } = await Promise.resolve().then(() => (init_onepassword(), exports_onepassword));
+    const resolved = await traceSpan(spanName, () => withSdkRetry2(() => resolveGlobImportAll2(globPath, {
       auth,
       sdkFactory: testSeams?.sdkFactory,
       warn: (m) => console.error(m)
-    }));
+    }), spanName));
     addSpanMeta(spanName, { vars: Object.keys(resolved).length });
     for (const [k, v] of Object.entries(resolved)) {
       resolvedCache.set(k, v);
@@ -4650,8 +4836,8 @@ async function resolveEnvironmentShared(envId, auth) {
     return { resolved: await existing, cacheHit: true };
   const spanName = `op:env-resolve(${envId})`;
   const promise = (async () => {
-    const { readEnvironment: readEnvironment2, recordOpHydratedVars: recordOpHydratedVars2 } = await Promise.resolve().then(() => (init_onepassword(), exports_onepassword));
-    const resolved = await traceSpan(spanName, () => readEnvironment2(envId, { auth, sdkFactory: testSeams?.sdkFactory }));
+    const { readEnvironment: readEnvironment2, recordOpHydratedVars: recordOpHydratedVars2, withSdkRetry: withSdkRetry2 } = await Promise.resolve().then(() => (init_onepassword(), exports_onepassword));
+    const resolved = await traceSpan(spanName, () => withSdkRetry2(() => readEnvironment2(envId, { auth, sdkFactory: testSeams?.sdkFactory }), spanName));
     addSpanMeta(spanName, { vars: Object.keys(resolved).length });
     for (const [k, v] of Object.entries(resolved)) {
       resolvedCache.set(k, v);
@@ -4686,6 +4872,8 @@ async function resolveOpKeyForEnvVars(wanted, opts = {}) {
     else
       stillWanted.add(w);
   }
+  for (const skip of inheritedUnavailable())
+    stillWanted.delete(skip);
   if (stillWanted.size === 0)
     return cached;
   const label = `op:resolve(${[...stillWanted].sort().join(",")})`;
@@ -4712,6 +4900,7 @@ async function resolveOpKeyForEnvVars(wanted, opts = {}) {
       resolvedCache.set(k, v);
       out[k] = v;
     }
+    recordOpUnavailableVars([...wantNow].filter((w) => !(w in resolved)));
     return out;
   }, label);
 }
@@ -4738,7 +4927,13 @@ async function resolveOpKeyForEnvVarsInner(wanted, opts = {}, span) {
       throw err;
     }
   }
-  const { collectConfigImports: collectConfigImports2, resolveSecrets: resolveSecrets2, recordOpHydratedVars: recordOpHydratedVars2, recordOpFailure: recordOpFailure2 } = await Promise.resolve().then(() => (init_onepassword(), exports_onepassword));
+  const {
+    collectConfigImports: collectConfigImports2,
+    resolveSecrets: resolveSecrets2,
+    recordOpHydratedVars: recordOpHydratedVars2,
+    recordOpFailure: recordOpFailure2,
+    withSdkRetry: withSdkRetry2
+  } = await Promise.resolve().then(() => (init_onepassword(), exports_onepassword));
   const cfg = readConfigRaw();
   const out = {};
   try {
@@ -4751,10 +4946,7 @@ async function resolveOpKeyForEnvVarsInner(wanted, opts = {}, span) {
         wantedRefs[envVar] = ref;
     }
     if (Object.keys(wantedRefs).length > 0) {
-      const resolved = await resolveSecrets2(wantedRefs, {
-        auth,
-        sdkFactory: testSeams?.sdkFactory
-      });
+      const resolved = await withSdkRetry2(() => resolveSecrets2(wantedRefs, { auth, sdkFactory: testSeams?.sdkFactory }), "op:resolve-refs");
       Object.assign(out, resolved);
     }
     const stillWanted = new Set([...wanted].filter((w) => !(w in out)));
@@ -4791,10 +4983,7 @@ async function resolveOpKeyForEnvVarsInner(wanted, opts = {}, span) {
           customRefs[envVar] = apiKey;
       }
       if (Object.keys(customRefs).length > 0) {
-        const resolved = await resolveSecrets2(customRefs, {
-          auth,
-          sdkFactory: testSeams?.sdkFactory
-        });
+        const resolved = await withSdkRetry2(() => resolveSecrets2(customRefs, { auth, sdkFactory: testSeams?.sdkFactory }), "op:resolve-custom-endpoint-refs");
         Object.assign(out, resolved);
       }
     }
@@ -4837,11 +5026,12 @@ async function resolveOpKeyForEnvVarsInner(wanted, opts = {}, span) {
     recordOpHydratedVars2(Object.keys(out));
   return out;
 }
-var warnedMessages, OpAuthError, cachedSdkAuth, sdkAuthResolved = false, authInFlight, testSeams, sniffed, opQueue, resolvedCache, globResolutions, globResolvedVars, environmentResolutions;
+var warnedMessages, opUnavailableVars, OP_UNAVAILABLE_ENV = "CLAUDISH_OP_UNAVAILABLE", OpAuthError, cachedSdkAuth, sdkAuthResolved = false, authInFlight, testSeams, sniffed, opQueue, resolvedCache, globResolutions, globResolvedVars, environmentResolutions;
 var init_op_source = __esm(() => {
   init_onepassword_config();
   init_startup_trace();
   warnedMessages = new Set;
+  opUnavailableVars = new Set;
   OpAuthError = class OpAuthError extends Error {
     constructor(message) {
       super(message);
@@ -26938,15 +27128,15 @@ __export(exports_profile_config, {
   configExists: () => configExists,
   activeConfigFile: () => activeConfigFile
 });
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname as dirname3, join as join6, parse as parse6 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname4, join as join7, parse as parse6 } from "path";
 function activeConfigFile() {
   return activeGlobalConfigFile(CONFIG_FILE);
 }
 function ensureConfigDir() {
   if (!existsSync5(CONFIG_DIR)) {
-    mkdirSync4(CONFIG_DIR, { recursive: true });
+    mkdirSync5(CONFIG_DIR, { recursive: true });
   }
 }
 function loadConfig() {
@@ -26957,7 +27147,7 @@ function loadConfig() {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const content = readFileSync4(activeFile, "utf-8");
+    const content = readFileSync5(activeFile, "utf-8");
     const config2 = JSON.parse(content);
     const merged = {
       version: config2.version || DEFAULT_CONFIG.version,
@@ -27006,6 +27196,9 @@ function loadConfig() {
     if (config2.customEndpoints !== undefined) {
       merged.customEndpoints = config2.customEndpoints;
     }
+    if (config2.behavior !== undefined) {
+      merged.behavior = config2.behavior;
+    }
     return merged;
   } catch (error46) {
     console.error(`Warning: Failed to load config, using defaults: ${error46}`);
@@ -27024,26 +27217,26 @@ function getConfigPath() {
   return CONFIG_FILE;
 }
 function getLocalConfigPath() {
-  const home = homedir6();
+  const home = homedir7();
   let dir = process.cwd();
   const root = parse6(dir).root;
   while (dir !== root && dir !== home) {
-    const candidate = join6(dir, LOCAL_CONFIG_FILENAME);
+    const candidate = join7(dir, LOCAL_CONFIG_FILENAME);
     if (existsSync5(candidate))
       return candidate;
-    if (existsSync5(join6(dir, ".git"))) {
+    if (existsSync5(join7(dir, ".git"))) {
       return candidate;
     }
-    dir = dirname3(dir);
+    dir = dirname4(dir);
   }
-  return join6(process.cwd(), LOCAL_CONFIG_FILENAME);
+  return join7(process.cwd(), LOCAL_CONFIG_FILENAME);
 }
 function localConfigExists() {
   return existsSync5(getLocalConfigPath());
 }
 function isProjectDirectory() {
   const cwd = process.cwd();
-  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync5(join6(cwd, f)));
+  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync5(join7(cwd, f)));
 }
 function loadLocalConfig() {
   if (getConfigFileOverride())
@@ -27053,7 +27246,7 @@ function loadLocalConfig() {
     return null;
   }
   try {
-    const content = readFileSync4(localPath, "utf-8");
+    const content = readFileSync5(localPath, "utf-8");
     const config2 = JSON.parse(content);
     return {
       ...config2,
@@ -27312,8 +27505,8 @@ function disableLocalProvider(providerName) {
 }
 var CONFIG_DIR, CONFIG_FILE, LOCAL_CONFIG_FILENAME = ".claudish.json", DEFAULT_CONFIG;
 var init_profile_config = __esm(() => {
-  CONFIG_DIR = join6(homedir6(), ".claudish");
-  CONFIG_FILE = join6(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join7(homedir7(), ".claudish");
+  CONFIG_FILE = join7(CONFIG_DIR, "config.json");
   DEFAULT_CONFIG = {
     version: "1.0.0",
     defaultProfile: "default",
@@ -28040,8 +28233,8 @@ var init_provider_definitions = __esm(() => {
 
 // src/auth/credentials/api-key-credential.ts
 import { existsSync as existsSync6 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join7 } from "path";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
 function realValue(v) {
   if (!v)
     return;
@@ -28083,7 +28276,7 @@ class ApiKeyCredentialProvider {
     if (!this.oauthFallback)
       return false;
     try {
-      return existsSync6(join7(homedir7(), ".claudish", this.oauthFallback));
+      return existsSync6(join8(homedir8(), ".claudish", this.oauthFallback));
     } catch {
       return false;
     }
@@ -28159,10 +28352,10 @@ var init_api_key_credential = __esm(() => {
 // src/auth/codex-oauth.ts
 import { exec } from "child_process";
 import { createHash as createHash2, randomBytes } from "crypto";
-import { closeSync, existsSync as existsSync7, openSync, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeSync } from "fs";
+import { closeSync as closeSync2, existsSync as existsSync7, openSync as openSync2, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeSync as writeSync2 } from "fs";
 import { createServer } from "http";
-import { homedir as homedir8 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join9 } from "path";
 import { promisify } from "util";
 
 class CodexOAuth {
@@ -28188,8 +28381,8 @@ class CodexOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join8(homedir8(), ".claudish");
-    return join8(claudishDir, "codex-oauth.json");
+    const claudishDir = join9(homedir9(), ".claudish");
+    return join9(claudishDir, "codex-oauth.json");
   }
   async login() {
     log("[CodexOAuth] Starting OAuth login flow");
@@ -28297,7 +28490,7 @@ Details: ${e.message}`);
       return null;
     }
     try {
-      const data = readFileSync5(credPath, "utf-8");
+      const data = readFileSync6(credPath, "utf-8");
       const credentials = JSON.parse(data);
       if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at) {
         log("[CodexOAuth] Invalid credentials file structure");
@@ -28312,17 +28505,17 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join8(homedir8(), ".claudish");
+    const claudishDir = join9(homedir9(), ".claudish");
     if (!existsSync7(claudishDir)) {
-      const { mkdirSync: mkdirSync5 } = __require("fs");
-      mkdirSync5(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync6 } = __require("fs");
+      mkdirSync6(claudishDir, { recursive: true });
     }
-    const fd = openSync(credPath, "w", 384);
+    const fd = openSync2(credPath, "w", 384);
     try {
       const data = JSON.stringify(credentials, null, 2);
-      writeSync(fd, data, 0, "utf-8");
+      writeSync2(fd, data, 0, "utf-8");
     } finally {
-      closeSync(fd);
+      closeSync2(fd);
     }
     log(`[CodexOAuth] Credentials saved to ${credPath}`);
   }
@@ -28623,10 +28816,10 @@ var init_codex_credential = __esm(() => {
 // src/auth/gemini-oauth.ts
 import { exec as exec2 } from "child_process";
 import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
-import { closeSync as closeSync2, existsSync as existsSync8, openSync as openSync2, readFileSync as readFileSync6, unlinkSync as unlinkSync3, writeSync as writeSync2 } from "fs";
+import { closeSync as closeSync3, existsSync as existsSync8, openSync as openSync3, readFileSync as readFileSync7, unlinkSync as unlinkSync3, writeSync as writeSync3 } from "fs";
 import { createServer as createServer2 } from "http";
-import { homedir as homedir9 } from "os";
-import { join as join9 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join10 } from "path";
 import { promisify as promisify2 } from "util";
 
 class GeminiOAuth {
@@ -28652,8 +28845,8 @@ class GeminiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join9(homedir9(), ".claudish");
-    return join9(claudishDir, "gemini-oauth.json");
+    const claudishDir = join10(homedir10(), ".claudish");
+    return join10(claudishDir, "gemini-oauth.json");
   }
   async login() {
     log("[GeminiOAuth] Starting OAuth login flow");
@@ -28755,7 +28948,7 @@ Details: ${e.message}`);
       return null;
     }
     try {
-      const data = readFileSync6(credPath, "utf-8");
+      const data = readFileSync7(credPath, "utf-8");
       const credentials = JSON.parse(data);
       if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at) {
         log("[GeminiOAuth] Invalid credentials file structure");
@@ -28770,17 +28963,17 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join9(homedir9(), ".claudish");
+    const claudishDir = join10(homedir10(), ".claudish");
     if (!existsSync8(claudishDir)) {
-      const { mkdirSync: mkdirSync5 } = __require("fs");
-      mkdirSync5(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync6 } = __require("fs");
+      mkdirSync6(claudishDir, { recursive: true });
     }
-    const fd = openSync2(credPath, "w", 384);
+    const fd = openSync3(credPath, "w", 384);
     try {
       const data = JSON.stringify(credentials, null, 2);
-      writeSync2(fd, data, 0, "utf-8");
+      writeSync3(fd, data, 0, "utf-8");
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
     log(`[GeminiOAuth] Credentials saved to ${credPath}`);
   }
@@ -29134,18 +29327,18 @@ var init_gemini_oauth = __esm(() => {
 });
 
 // src/auth/oauth-registry.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join10 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join11 } from "path";
 function hasValidOAuthCredentials(descriptor) {
-  const credPath = join10(homedir10(), ".claudish", descriptor.credentialFile);
+  const credPath = join11(homedir11(), ".claudish", descriptor.credentialFile);
   if (!existsSync9(credPath))
     return false;
   if (descriptor.validationMode === "file-exists") {
     return true;
   }
   try {
-    const data = JSON.parse(readFileSync7(credPath, "utf-8"));
+    const data = JSON.parse(readFileSync8(credPath, "utf-8"));
     if (!data.access_token)
       return false;
     if (data.refresh_token)
@@ -29255,9 +29448,9 @@ var init_gemini_credential = __esm(() => {
 // src/auth/kimi-oauth.ts
 import { exec as exec3 } from "child_process";
 import { randomBytes as randomBytes3 } from "crypto";
-import { closeSync as closeSync3, existsSync as existsSync10, openSync as openSync3, readFileSync as readFileSync8, unlinkSync as unlinkSync4, writeSync as writeSync3 } from "fs";
-import { homedir as homedir11, hostname as hostname3, platform, release } from "os";
-import { join as join11 } from "path";
+import { closeSync as closeSync4, existsSync as existsSync10, openSync as openSync4, readFileSync as readFileSync9, unlinkSync as unlinkSync4, writeSync as writeSync4 } from "fs";
+import { homedir as homedir12, hostname as hostname3, platform, release as release2 } from "os";
+import { join as join12 } from "path";
 import { promisify as promisify3 } from "util";
 
 class KimiOAuth {
@@ -29285,23 +29478,23 @@ class KimiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join11(homedir11(), ".claudish");
-    return join11(claudishDir, "kimi-oauth.json");
+    const claudishDir = join12(homedir12(), ".claudish");
+    return join12(claudishDir, "kimi-oauth.json");
   }
   getDeviceIdPath() {
-    const claudishDir = join11(homedir11(), ".claudish");
-    return join11(claudishDir, "kimi-device-id");
+    const claudishDir = join12(homedir12(), ".claudish");
+    return join12(claudishDir, "kimi-device-id");
   }
   loadOrCreateDeviceId() {
     const deviceIdPath = this.getDeviceIdPath();
-    const claudishDir = join11(homedir11(), ".claudish");
+    const claudishDir = join12(homedir12(), ".claudish");
     if (!existsSync10(claudishDir)) {
-      const { mkdirSync: mkdirSync5 } = __require("fs");
-      mkdirSync5(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync6 } = __require("fs");
+      mkdirSync6(claudishDir, { recursive: true });
     }
     if (existsSync10(deviceIdPath)) {
       try {
-        const deviceId2 = readFileSync8(deviceIdPath, "utf-8").trim();
+        const deviceId2 = readFileSync9(deviceIdPath, "utf-8").trim();
         if (deviceId2) {
           return deviceId2;
         }
@@ -29311,11 +29504,11 @@ class KimiOAuth {
     }
     const deviceId = randomBytes3(16).toString("hex").replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
     try {
-      const fd = openSync3(deviceIdPath, "w", 384);
+      const fd = openSync4(deviceIdPath, "w", 384);
       try {
-        writeSync3(fd, deviceId, 0, "utf-8");
+        writeSync4(fd, deviceId, 0, "utf-8");
       } finally {
-        closeSync3(fd);
+        closeSync4(fd);
       }
       log(`[KimiOAuth] New device ID created: ${deviceId}`);
     } catch (e) {
@@ -29332,7 +29525,7 @@ class KimiOAuth {
       "X-Msh-Version": this.getVersion(),
       "X-Msh-Device-Name": hostname3(),
       "X-Msh-Device-Model": `${platform()}-${process.arch}`,
-      "X-Msh-Os-Version": release(),
+      "X-Msh-Os-Version": release2(),
       "X-Msh-Device-Id": this.deviceId
     };
   }
@@ -29560,7 +29753,7 @@ Details: ${e.message}`);
       return null;
     }
     try {
-      const data = readFileSync8(credPath, "utf-8");
+      const data = readFileSync9(credPath, "utf-8");
       const credentials = JSON.parse(data);
       if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at || !credentials.scope || !credentials.token_type) {
         log("[KimiOAuth] Invalid credentials file structure");
@@ -29575,17 +29768,17 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join11(homedir11(), ".claudish");
+    const claudishDir = join12(homedir12(), ".claudish");
     if (!existsSync10(claudishDir)) {
-      const { mkdirSync: mkdirSync5 } = __require("fs");
-      mkdirSync5(claudishDir, { recursive: true });
+      const { mkdirSync: mkdirSync6 } = __require("fs");
+      mkdirSync6(claudishDir, { recursive: true });
     }
-    const fd = openSync3(credPath, "w", 384);
+    const fd = openSync4(credPath, "w", 384);
     try {
       const data = JSON.stringify(credentials, null, 2);
-      writeSync3(fd, data, 0, "utf-8");
+      writeSync4(fd, data, 0, "utf-8");
     } finally {
-      closeSync3(fd);
+      closeSync4(fd);
     }
     log(`[KimiOAuth] Credentials saved to ${credPath}`);
   }
@@ -29751,8 +29944,8 @@ var init_native_anthropic_credential = __esm(() => {
 // src/auth/vertex-auth.ts
 import { exec as exec4 } from "child_process";
 import { existsSync as existsSync11 } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join12 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join13 } from "path";
 import { promisify as promisify4 } from "util";
 
 class VertexAuthManager {
@@ -29807,7 +30000,7 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join12(homedir12(), ".config/gcloud/application_default_credentials.json");
+      const adcPath = join13(homedir13(), ".config/gcloud/application_default_credentials.json");
       if (!existsSync11(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
@@ -29871,7 +30064,7 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join12(homedir12(), ".config/gcloud/application_default_credentials.json");
+  const adcPath = join13(homedir13(), ".config/gcloud/application_default_credentials.json");
   const hasADC = existsSync11(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
@@ -30419,15 +30612,15 @@ var init_routing_hints = __esm(() => {
 });
 
 // src/providers/all-models-cache.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir13 } from "os";
-import { dirname as dirname4, join as join13 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir14 } from "os";
+import { dirname as dirname5, join as join14 } from "path";
 function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
   if (!existsSync12(path))
     return null;
   let raw;
   try {
-    raw = JSON.parse(readFileSync9(path, "utf-8"));
+    raw = JSON.parse(readFileSync10(path, "utf-8"));
   } catch {
     return null;
   }
@@ -30452,12 +30645,12 @@ function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
     entries: data.entries ?? existing?.entries ?? [],
     models: data.models ?? existing?.models ?? []
   };
-  mkdirSync5(dirname4(path), { recursive: true });
+  mkdirSync6(dirname5(path), { recursive: true });
   writeFileSync6(path, JSON.stringify(merged), "utf-8");
 }
 var ALL_MODELS_CACHE_PATH;
 var init_all_models_cache = __esm(() => {
-  ALL_MODELS_CACHE_PATH = join13(homedir13(), ".claudish", "all-models.json");
+  ALL_MODELS_CACHE_PATH = join14(homedir14(), ".claudish", "all-models.json");
 });
 
 // src/adapters/model-catalog.ts
@@ -31284,10 +31477,21 @@ async function prehydrateCredentialsForSpawn(models) {
     return;
   try {
     await validateApiKeysForModels(wanted);
+    publishOpSkipList();
   } catch {}
 }
+function publishOpSkipList() {
+  if (getOpFailures().length > 0)
+    return;
+  const unavailable = getOpUnavailableVars();
+  if (unavailable.length === 0)
+    return;
+  process.env[OP_UNAVAILABLE_ENV] = unavailable.join(",");
+}
 var init_prehydrate = __esm(() => {
+  init_onepassword();
   init_provider_resolver();
+  init_op_source();
 });
 
 // src/channel/diagnostics.ts
@@ -31542,9 +31746,9 @@ var init_signal_watcher = __esm(() => {
 // src/channel/session-manager.ts
 import { spawn } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { createWriteStream, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join14 } from "path";
+import { createWriteStream, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir15 } from "os";
+import { join as join15 } from "path";
 
 class SessionManager {
   sessions = new Map;
@@ -31564,10 +31768,10 @@ class SessionManager {
     const sessionId = randomUUID2().slice(0, 8);
     const timeout = Math.min(opts.timeoutSeconds ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     const startedAt = new Date().toISOString();
-    const sessionDir = join14(homedir14(), ".claudish", "sessions", sessionId);
-    mkdirSync6(sessionDir, { recursive: true });
+    const sessionDir = join15(homedir15(), ".claudish", "sessions", sessionId);
+    mkdirSync7(sessionDir, { recursive: true });
     if (opts.prompt) {
-      writeFileSync7(join14(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync7(join15(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     }
     const args = ["--model", opts.model, "-y", "--stdin", "--quiet", ...opts.claudishFlags ?? []];
     const proc = spawn("claudish", args, {
@@ -31594,7 +31798,7 @@ class SessionManager {
         });
       }
     });
-    const outputLogStream = createWriteStream(join14(sessionDir, "output.log"));
+    const outputLogStream = createWriteStream(join15(sessionDir, "output.log"));
     const entry = {
       info: {
         sessionId,
@@ -31641,9 +31845,9 @@ class SessionManager {
       watcher.processExited(code);
       outputLogStream.end();
       if (entry.stderr) {
-        writeFileSync7(join14(sessionDir, "stderr.log"), entry.stderr, "utf-8");
+        writeFileSync7(join15(sessionDir, "stderr.log"), entry.stderr, "utf-8");
       }
-      writeFileSync7(join14(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
+      writeFileSync7(join15(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
       this.cleanupSigint();
     });
     proc.on("error", (err) => {
@@ -31816,9 +32020,9 @@ var init_cache_ttl = __esm(() => {
 });
 
 // src/model-loader.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir16 } from "os";
+import { join as join16 } from "path";
 function groupRecommendedModels(entries) {
   const byId = new Map;
   for (const entry of entries) {
@@ -31916,7 +32120,7 @@ async function getRecommendedModels(opts = {}) {
   }
   if (!forceRefresh && existsSync13(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync10(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync11(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -31932,8 +32136,8 @@ async function getRecommendedModels(opts = {}) {
       if (data.models && data.models.length > 0) {
         _cachedRecommendedModels = data;
         try {
-          const cacheDir = join15(homedir15(), ".claudish");
-          mkdirSync7(cacheDir, { recursive: true });
+          const cacheDir = join16(homedir16(), ".claudish");
+          mkdirSync8(cacheDir, { recursive: true });
           writeFileSync8(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
         } catch {}
         return data;
@@ -31947,7 +32151,7 @@ function getRecommendedModelsSync() {
     return _cachedRecommendedModels;
   if (existsSync13(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync10(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync11(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -32071,7 +32275,7 @@ var _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels =
 var init_model_loader = __esm(() => {
   init_cache_ttl();
   FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommended`;
-  RECOMMENDED_MODELS_CACHE_PATH = join15(homedir15(), ".claudish", "recommended-models-cache.json");
+  RECOMMENDED_MODELS_CACHE_PATH = join16(homedir16(), ".claudish", "recommended-models-cache.json");
   FIREBASE_SLUG_TO_PROVIDER_NAME = {
     openai: "openai",
     google: "google",
@@ -32119,6 +32323,44 @@ async function isPortAvailable(port) {
 }
 var init_port_manager = () => {};
 
+// src/redact.ts
+function isPlaceholder(value) {
+  return PLACEHOLDER.test(value.trim());
+}
+function redactSecrets(text) {
+  if (!text)
+    return "";
+  let out = text;
+  out = out.replace(ASSIGNMENT_RE, (match, lhs, value) => isPlaceholder(value) ? match : `${lhs}${MASK}`);
+  for (const { re } of TOKEN_PATTERNS) {
+    out = out.replace(re, (match) => {
+      const scheme = /^(Bearer|Basic|Token)\s/.exec(match);
+      return scheme ? `${scheme[1]} ${MASK}` : MASK;
+    });
+  }
+  return out;
+}
+function sanitizeForReport(text) {
+  if (!text)
+    return "";
+  return redactSecrets(text).replace(/\/Users\/[^/\s]+/g, "/Users/***").replace(/\/home\/[^/\s]+/g, "/home/***").replace(/[A-Z]:\\Users\\[^\\\s]+/gi, "C:\\Users\\***").replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, "***@***.***");
+}
+var MASK = "***REDACTED***", PLACEHOLDER, ASSIGNMENT_RE, TOKEN_PATTERNS;
+var init_redact = __esm(() => {
+  PLACEHOLDER = /^(['"`]?)(your[-_a-z0-9]*|<[^>]*>|\.\.\.|x{3,}|\*{3,}|REDACTED|CHANGEME|TODO|\$\{[^}]*\}|)(['"`]?)$/i;
+  ASSIGNMENT_RE = /(["']?\b[A-Z][A-Z0-9_]*(?:_API_KEY|_KEY|_TOKEN|_SECRET|_PASSWORD)\b["']?\s*[:=]\s*)(["'`]?\$\{[^}]*\}["'`]?|["'`]?[^\s"'`,}]+["'`]?)/g;
+  TOKEN_PATTERNS = [
+    { name: "sk", re: /\bsk-[A-Za-z0-9_-]{16,}/g },
+    { name: "google", re: /\bAIza[A-Za-z0-9_-]{20,}/g },
+    { name: "xai", re: /\bxai-[A-Za-z0-9_-]{16,}/g },
+    { name: "github", re: /\bgh[posur]_[A-Za-z0-9]{20,}/g },
+    { name: "aws", re: /\bAKIA[0-9A-Z]{12,}/g },
+    { name: "jwt", re: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g },
+    { name: "zhipu", re: /\b[0-9a-f]{32}\.[A-Za-z0-9]{16}\b/g },
+    { name: "bearer", re: /\b(?:Bearer|Basic|Token)\s+[A-Za-z0-9_.\-+/=]{12,}/g }
+  ];
+});
+
 // ../../node_modules/.bun/hono@4.10.6/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
@@ -34112,9 +34354,12 @@ function transformOpenAIToClaude(claudeRequestInput) {
 var init_transform = () => {};
 
 // src/handlers/shared/format/openai-tools.ts
+function emptyParamsSchema() {
+  return { type: "object", properties: {} };
+}
 function sanitizeSchemaForOpenAI(schema) {
   if (!schema || typeof schema !== "object") {
-    return removeUriFormat(schema);
+    return emptyParamsSchema();
   }
   let root = { ...schema };
   const combinerKey = ["oneOf", "anyOf", "allOf"].find((k) => Array.isArray(root[k]) && root[k].length > 0);
@@ -34156,8 +34401,8 @@ function summarizeToolDescription(name, description) {
   return firstSentence;
 }
 function summarizeToolParameters(schema) {
-  if (!schema)
-    return schema;
+  if (!schema || typeof schema !== "object")
+    return emptyParamsSchema();
   const summarized = sanitizeSchemaForOpenAI({ ...schema });
   if (summarized.properties) {
     for (const prop of Object.values(summarized.properties)) {
@@ -36790,6 +37035,555 @@ ${text}`;
   };
 });
 
+// ../../node_modules/.bun/zod@4.1.13/node_modules/zod/index.js
+var init_zod = __esm(() => {
+  init_external2();
+  init_external2();
+});
+
+// src/behavior/config.ts
+function parseBehaviorConfig(raw2) {
+  if (raw2 === undefined || raw2 === null)
+    return {};
+  const result = BehaviorConfigSchema.safeParse(raw2);
+  if (!result.success) {
+    logStderr(`[behavior] Ignoring invalid "behavior" config: ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
+    return {};
+  }
+  return result.data;
+}
+function resolveSeverity(ruleId, defaultSeverity, config2) {
+  const rules = config2.rules;
+  if (!rules)
+    return defaultSeverity;
+  const exact = rules[ruleId];
+  if (exact)
+    return exact;
+  let best = null;
+  for (const [pattern, severity] of Object.entries(rules)) {
+    if (!pattern.includes("*"))
+      continue;
+    if (!globMatches(pattern, ruleId))
+      continue;
+    const len = pattern.replace(/\*/g, "").length;
+    if (!best || len > best.len)
+      best = { len, severity };
+  }
+  return best ? best.severity : defaultSeverity;
+}
+function globMatches(pattern, value) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  return new RegExp(`^${escaped}$`).test(value);
+}
+var SeveritySchema, BehaviorConfigSchema;
+var init_config = __esm(() => {
+  init_zod();
+  init_logger();
+  SeveritySchema = exports_external.enum(["off", "warn", "fix"]);
+  BehaviorConfigSchema = exports_external.object({
+    preset: exports_external.string().optional(),
+    rules: exports_external.record(exports_external.string(), SeveritySchema).optional(),
+    hooks: exports_external.array(exports_external.string()).optional(),
+    observer: exports_external.object({
+      enabled: exports_external.boolean().optional(),
+      mode: exports_external.enum(["off", "suggest", "enforce"]).optional(),
+      model: exports_external.string().optional(),
+      timeoutMs: exports_external.number().int().positive().optional()
+    }).optional()
+  });
+});
+
+// src/behavior/harness.ts
+function textOf(value) {
+  if (!value)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (Array.isArray(value)) {
+    let out = "";
+    for (const part of value) {
+      if (typeof part === "string")
+        out += part;
+      else if (typeof part?.text === "string")
+        out += part.text;
+      else if (typeof part?.content === "string")
+        out += part.content;
+    }
+    return out;
+  }
+  if (typeof value?.text === "string")
+    return value.text;
+  return "";
+}
+function matchPlanPath(text) {
+  if (!PLAN_MODE_HINT.test(text))
+    return;
+  for (const re of PLAN_PATH_PATTERNS) {
+    const m = re.exec(text);
+    if (m?.[1])
+      return m[1];
+  }
+  return;
+}
+function detectHarnessFacts(claudeRequest) {
+  const facts = { planModeActive: false };
+  let planPath = matchPlanPath(textOf(claudeRequest?.system));
+  if (!planPath && Array.isArray(claudeRequest?.messages)) {
+    const messages = claudeRequest.messages;
+    for (let i = messages.length - 1;i >= 0; i--) {
+      planPath = matchPlanPath(textOf(messages[i]?.content));
+      if (planPath)
+        break;
+    }
+  }
+  if (planPath) {
+    facts.planModeActive = true;
+    facts.planFilePath = planPath;
+    const slash = planPath.lastIndexOf("/");
+    if (slash > 0)
+      facts.planDir = planPath.slice(0, slash);
+  }
+  return facts;
+}
+var PLAN_PATH_PATTERNS, PLAN_MODE_HINT;
+var init_harness = __esm(() => {
+  PLAN_PATH_PATTERNS = [
+    /You should create your plan at\s+(\S+?\.md)/,
+    /A plan file already exists at\s+(\S+?\.md)/,
+    /Read-only except plan file\s*\(([^)]+\.md)\)/
+  ];
+  PLAN_MODE_HINT = /plan file|create your plan at|Plan mode is active|Plan mode still active/i;
+});
+
+// src/behavior/engine.ts
+class BehaviorSession {
+  active;
+  modelId;
+  providerName;
+  facts = { planModeActive: false };
+  bufferedTools = new Set;
+  constructor(active, modelId, providerName) {
+    this.active = active;
+    this.modelId = modelId;
+    this.providerName = providerName;
+  }
+  armBuffering() {
+    const armed = new Set;
+    for (const { rule, severity } of this.active) {
+      if (severity !== "fix")
+        continue;
+      if (rule.armed && !rule.armed(this.facts))
+        continue;
+      for (const t of rule.interceptsTools ?? [])
+        armed.add(t);
+    }
+    this.bufferedTools = armed;
+  }
+  get harness() {
+    return this.facts;
+  }
+  get isNoop() {
+    return this.active.length === 0;
+  }
+  applyRequest(claudeRequest, claudeTools, tools, messages) {
+    if (this.active.length === 0)
+      return;
+    this.facts = detectHarnessFacts(claudeRequest);
+    this.armBuffering();
+    const ctx = {
+      modelId: this.modelId,
+      providerName: this.providerName,
+      isNativeAnthropic: false,
+      claudeRequest,
+      claudeTools,
+      tools,
+      messages,
+      harness: this.facts
+    };
+    for (const { rule, severity } of this.active) {
+      if (!rule.onRequest)
+        continue;
+      let actions = [];
+      try {
+        actions = rule.onRequest(ctx) ?? [];
+      } catch (err) {
+        log(`[behavior] rule ${rule.id} onRequest threw: ${err}`);
+        continue;
+      }
+      for (const action of actions)
+        this.applyAction(rule.id, severity, action, ctx);
+    }
+  }
+  interceptsTool(toolName) {
+    return this.bufferedTools.has(toolName);
+  }
+  repairToolCall(toolName, rawArgs) {
+    if (!this.bufferedTools.has(toolName))
+      return null;
+    let args = {};
+    try {
+      const parsed = JSON.parse(rawArgs || "{}");
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+        args = parsed;
+    } catch {
+      return null;
+    }
+    let changed = false;
+    for (const { rule, severity } of this.active) {
+      if (!rule.onToolCall)
+        continue;
+      if (!(rule.interceptsTools ?? []).includes(toolName))
+        continue;
+      let actions = [];
+      try {
+        actions = rule.onToolCall({
+          modelId: this.modelId,
+          toolName,
+          args,
+          rawArgs,
+          harness: this.facts
+        }) ?? [];
+      } catch (err) {
+        log(`[behavior] rule ${rule.id} onToolCall threw: ${err}`);
+        continue;
+      }
+      for (const action of actions) {
+        if (action.type === "warn") {
+          log(`[behavior] ${rule.id} (warn): ${action.message}`);
+          continue;
+        }
+        if (action.type !== "repairToolArgs")
+          continue;
+        if (severity !== "fix") {
+          log(`[behavior] ${rule.id} (warn-only, not applied): ${action.reason}`);
+          continue;
+        }
+        args = action.args;
+        changed = true;
+        log(`[behavior] ${rule.id} repaired ${toolName}: ${action.reason}`);
+      }
+    }
+    return changed ? JSON.stringify(args) : null;
+  }
+  applyAction(ruleId, severity, action, ctx) {
+    if (action.type === "warn") {
+      log(`[behavior] ${ruleId} (warn): ${action.message}`);
+      return;
+    }
+    if (severity !== "fix") {
+      log(`[behavior] ${ruleId} (warn-only, not applied): ${action.type}`);
+      return;
+    }
+    switch (action.type) {
+      case "injectSystemNote": {
+        const req = ctx.claudeRequest;
+        if (typeof req.system === "string") {
+          req.system = `${req.system}
+
+${action.text}`;
+        } else if (Array.isArray(req.system)) {
+          req.system.push({ type: "text", text: action.text });
+        } else {
+          req.system = action.text;
+        }
+        log(`[behavior] ${ruleId} injected system note (${action.text.length} chars)`);
+        break;
+      }
+      case "rewriteToolDescription": {
+        let hits = 0;
+        for (const t of ctx.claudeTools) {
+          if (t?.name !== action.tool)
+            continue;
+          t.description = `${t.description ?? ""}${action.append}`;
+          hits++;
+        }
+        for (const t of ctx.tools) {
+          const fn = t?.function ?? t;
+          if (fn?.name !== action.tool)
+            continue;
+          fn.description = `${fn.description ?? ""}${action.append}`;
+          hits++;
+        }
+        log(`[behavior] ${ruleId} rewrote description of ${action.tool} (${hits} site(s))`);
+        break;
+      }
+      case "repairToolArgs":
+        log(`[behavior] ${ruleId} returned repairToolArgs from onRequest \u2014 ignored`);
+        break;
+    }
+  }
+}
+
+class BehaviorEngine {
+  config;
+  rules;
+  constructor(config2, rules) {
+    this.config = config2;
+    this.rules = rules;
+  }
+  startSession(params) {
+    const active = [];
+    if (!params.isNativeAnthropic) {
+      for (const rule of this.rules) {
+        const severity = resolveSeverity(rule.id, rule.defaultSeverity, this.config);
+        if (severity === "off")
+          continue;
+        let applies = false;
+        try {
+          applies = rule.appliesTo(params);
+        } catch (err) {
+          log(`[behavior] rule ${rule.id} appliesTo threw: ${err}`);
+          continue;
+        }
+        if (applies)
+          active.push({ rule, severity });
+      }
+    }
+    if (active.length > 0) {
+      log(`[behavior] ${active.length} rule(s) active for ${params.modelId}: ` + active.map((a) => `${a.rule.id}=${a.severity}`).join(", "));
+    }
+    return new BehaviorSession(active, params.modelId, params.providerName);
+  }
+}
+var init_engine = __esm(() => {
+  init_logger();
+  init_config();
+  init_harness();
+});
+
+// src/behavior/rules/plan-mode.ts
+function directoryOf(filePath) {
+  const slash = filePath.lastIndexOf("/");
+  return slash > 0 ? filePath.slice(0, slash) : undefined;
+}
+var WRITE_TOOLS, planFilePathRule, PLAN_MODE_RULES;
+var init_plan_mode = __esm(() => {
+  WRITE_TOOLS = ["Write", "Edit", "NotebookEdit"];
+  planFilePathRule = {
+    id: "plan-mode/plan-file-path",
+    description: "Keep plan-mode writes on the plan file Claude Code assigned, and name that " + "path in the ExitPlanMode description.",
+    defaultSeverity: "fix",
+    interceptsTools: WRITE_TOOLS,
+    appliesTo: ({ isNativeAnthropic }) => !isNativeAnthropic,
+    armed: (facts) => facts.planModeActive === true,
+    onRequest(ctx) {
+      const { planModeActive, planFilePath } = ctx.harness;
+      if (!planModeActive || !planFilePath)
+        return [];
+      const hasExitPlanMode = ctx.claudeTools.some((t) => t?.name === "ExitPlanMode") || ctx.tools.some((t) => (t?.function ?? t)?.name === "ExitPlanMode");
+      if (!hasExitPlanMode)
+        return [];
+      return [
+        {
+          type: "rewriteToolDescription",
+          tool: "ExitPlanMode",
+          append: `
+
+## Plan file for THIS session
+Your plan MUST be written to exactly this path:
+${planFilePath}
+Do not invent a different filename, and do not derive one from the task. Claude Code reads only that exact path; a plan written anywhere else is invisible to it and the approval will show "No plan found".`
+        }
+      ];
+    },
+    onToolCall(ctx) {
+      const { planFilePath, planDir } = ctx.harness;
+      if (!planFilePath || !planDir)
+        return [];
+      const filePath = ctx.args.file_path;
+      if (typeof filePath !== "string" || filePath === planFilePath)
+        return [];
+      if (directoryOf(filePath) !== planDir)
+        return [];
+      return [
+        {
+          type: "repairToolArgs",
+          args: { ...ctx.args, file_path: planFilePath },
+          reason: `redirected ${ctx.toolName} from ${filePath} to the session's assigned ` + `plan file ${planFilePath}`
+        }
+      ];
+    }
+  };
+  PLAN_MODE_RULES = [planFilePathRule];
+});
+
+// src/behavior/hooks.ts
+import { isAbsolute, resolve } from "path";
+function isBehaviorRule(value) {
+  return !!value && typeof value === "object" && typeof value.id === "string" && value.id.length > 0 && typeof value.appliesTo === "function" && (value.onRequest === undefined || typeof value.onRequest === "function") && (value.onToolCall === undefined || typeof value.onToolCall === "function");
+}
+function collectRules(mod) {
+  const found = [];
+  const consider = (v) => {
+    if (Array.isArray(v))
+      v.forEach(consider);
+    else if (isBehaviorRule(v))
+      found.push(v);
+  };
+  consider(mod?.default);
+  consider(mod?.rules);
+  for (const [key, value] of Object.entries(mod ?? {})) {
+    if (key === "default" || key === "rules")
+      continue;
+    consider(value);
+  }
+  return [...new Set(found)];
+}
+function shortName(path) {
+  const base = path.split("/").pop() ?? path;
+  return base.replace(/\.[cm]?[jt]s$/, "");
+}
+async function loadHookRules(paths, cwd = process.cwd()) {
+  if (!paths?.length)
+    return [];
+  const loaded = [];
+  const seen = new Set;
+  for (const raw2 of paths) {
+    const abs = isAbsolute(raw2) ? raw2 : resolve(cwd, raw2);
+    const rules = await importHook(abs, raw2);
+    for (const rule of rules)
+      namespaceInto(rule, abs, seen, loaded);
+  }
+  if (loaded.length > 0) {
+    logStderr(`[behavior] Loaded ${loaded.length} hook rule(s): ${loaded.map((r) => r.id).join(", ")}`);
+  }
+  return loaded;
+}
+async function importHook(abs, raw2) {
+  let mod;
+  try {
+    mod = await import(abs);
+  } catch (err) {
+    logStderr(`[behavior] Skipping hook ${raw2}: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+  const rules = collectRules(mod);
+  if (rules.length === 0) {
+    logStderr(`[behavior] Hook ${raw2} exported no valid BehaviorRule \u2014 skipped`);
+  }
+  return rules;
+}
+function namespaceInto(rule, abs, seen, out) {
+  const namespaced = `hook:${shortName(abs)}/${rule.id}`;
+  if (seen.has(namespaced)) {
+    logStderr(`[behavior] Duplicate hook rule ${namespaced} \u2014 keeping the first`);
+    return;
+  }
+  seen.add(namespaced);
+  out.push({
+    ...rule,
+    id: namespaced,
+    defaultSeverity: rule.defaultSeverity ?? "warn"
+  });
+}
+var init_hooks = __esm(() => {
+  init_logger();
+});
+
+// src/behavior/observer/digest.ts
+var PATH_KEYS;
+var init_digest = __esm(() => {
+  PATH_KEYS = new Set(["file_path", "path", "notebook_path", "filePath"]);
+});
+
+// src/providers/ollama-discovery.ts
+function ollamaBaseUrl() {
+  return process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+}
+async function fetchOllamaModels(options = {}) {
+  const { enrichCapabilities = true } = options;
+  const host = ollamaBaseUrl();
+  try {
+    const response = await fetch(`${host}/api/tags`, {
+      signal: AbortSignal.timeout(3000)
+    });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    const models = data.models || [];
+    const enriched = await Promise.all(models.map(async (m) => {
+      let capabilities = [];
+      if (enrichCapabilities) {
+        try {
+          const showResponse = await fetch(`${host}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: m.name }),
+            signal: AbortSignal.timeout(2000)
+          });
+          if (showResponse.ok) {
+            const showData = await showResponse.json();
+            capabilities = showData.capabilities || [];
+          }
+        } catch {}
+      }
+      const nameLower = String(m.name).toLowerCase();
+      const supportsTools = capabilities.includes("tools");
+      const isEmbeddingModel = capabilities.includes("embedding") || nameLower.includes("embed");
+      const sizeInfo = m.details?.parameter_size || "unknown size";
+      const toolsIndicator = supportsTools ? "\u2713 tools" : "\u2717 no tools";
+      return {
+        id: `ollama/${m.name}`,
+        name: m.name,
+        description: `Local Ollama model (${sizeInfo}, ${toolsIndicator})`,
+        provider: "ollama",
+        pricing: { prompt: "0", completion: "0" },
+        isLocal: true,
+        supportsTools,
+        isEmbeddingModel,
+        capabilities,
+        details: m.details,
+        size: m.size
+      };
+    }));
+    return enriched.filter((m) => !m.isEmbeddingModel);
+  } catch {
+    return [];
+  }
+}
+
+// src/behavior/observer/client.ts
+var init_client = __esm(() => {
+  init_logger();
+});
+
+// src/behavior/observer/corpus.ts
+var WRITE_TOOLS2;
+var init_corpus = __esm(() => {
+  WRITE_TOOLS2 = new Set(["Write", "Edit", "NotebookEdit"]);
+});
+
+// src/behavior/index.ts
+function createBehaviorEngine(rawConfig, extraRules = []) {
+  return new BehaviorEngine(parseBehaviorConfig(rawConfig), [...BUILTIN_RULES, ...extraRules]);
+}
+function getBehaviorEngine() {
+  if (!sharedEngine) {
+    sharedEngine = createBehaviorEngine(loadConfig().behavior, hookRules);
+  }
+  return sharedEngine;
+}
+function registerHookRules(rules) {
+  hookRules = [...hookRules, ...rules];
+  sharedEngine = null;
+}
+var BUILTIN_RULES, sharedEngine = null, hookRules;
+var init_behavior = __esm(() => {
+  init_profile_config();
+  init_config();
+  init_engine();
+  init_plan_mode();
+  init_engine();
+  init_config();
+  init_harness();
+  init_hooks();
+  init_digest();
+  init_client();
+  init_corpus();
+  BUILTIN_RULES = [...PLAN_MODE_RULES];
+  hookRules = [];
+});
+
 // src/middleware/manager.ts
 class MiddlewareManager {
   middlewares = [];
@@ -37112,7 +37906,7 @@ class OpenAIProviderTransport {
             delayMs = 500 * (attempt + 1);
           }
           log(`[${this.displayName}] 429 rate limited, retry ${attempt + 1}/${maxRetries} in ${(delayMs / 1000).toFixed(1)}s`);
-          await new Promise((resolve) => setTimeout(resolve, delayMs));
+          await new Promise((resolve2) => setTimeout(resolve2, delayMs));
           continue;
         }
         return response;
@@ -37168,7 +37962,7 @@ var init_openai = __esm(() => {
 });
 
 // src/providers/catalog-query.ts
-import { statSync } from "fs";
+import { statSync as statSync2 } from "fs";
 function project(entry) {
   return {
     modelId: entry.modelId,
@@ -37181,7 +37975,7 @@ function project(entry) {
 function getCachedEntries() {
   let mtimeMs;
   try {
-    mtimeMs = statSync(ALL_MODELS_CACHE_PATH).mtimeMs;
+    mtimeMs = statSync2(ALL_MODELS_CACHE_PATH).mtimeMs;
   } catch {
     return null;
   }
@@ -37356,24 +38150,24 @@ var init_vision_proxy = __esm(() => {
 // src/stats-buffer.ts
 import {
   existsSync as existsSync14,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync11,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync12,
   renameSync,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir16 } from "os";
-import { join as join16 } from "path";
+import { homedir as homedir17 } from "os";
+import { join as join17 } from "path";
 function ensureDir() {
   if (!existsSync14(CLAUDISH_DIR)) {
-    mkdirSync8(CLAUDISH_DIR, { recursive: true });
+    mkdirSync9(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
   try {
     if (!existsSync14(BUFFER_FILE))
       return [];
-    const raw2 = readFileSync11(BUFFER_FILE, "utf-8");
+    const raw2 = readFileSync12(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw2);
     if (!Array.isArray(parsed.events))
       return [];
@@ -37398,7 +38192,7 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed };
-    const tmpFile = join16(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    const tmpFile = join17(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
     writeFileSync9(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync(tmpFile, BUFFER_FILE);
     memoryCache = trimmed;
@@ -37471,8 +38265,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, flushScheduled = false;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join16(homedir16(), ".claudish");
-  BUFFER_FILE = join16(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join17(homedir17(), ".claudish");
+  BUFFER_FILE = join17(CLAUDISH_DIR, "stats-buffer.json");
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
     try {
@@ -37831,11 +38625,11 @@ async function runConsentPrompt(ctx) {
   Does NOT send: prompts, paths, API keys, or credentials.
   Disable anytime: claudish telemetry off
 `);
-  const answer = await new Promise((resolve) => {
+  const answer = await new Promise((resolve2) => {
     const rl = createInterface({ input: process.stdin, output: process.stderr });
     rl.question("Send anonymous error report? [y/N] ", (ans) => {
       rl.close();
-      resolve(ans.trim().toLowerCase());
+      resolve2(ans.trim().toLowerCase());
     });
   });
   const accepted = answer === "y" || answer === "yes";
@@ -38576,8 +39370,8 @@ async function sniffResponsesStreamHead(response, opts = {}) {
         return { kind: "clean", response: replayResponse() };
       }
       let timer;
-      const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve("timeout"), remaining);
+      const timeout = new Promise((resolve2) => {
+        timer = setTimeout(() => resolve2("timeout"), remaining);
       });
       let result;
       try {
@@ -39306,6 +40100,7 @@ function createResponsesStreamHandler(c, response, opts) {
   let lastActivity = Date.now();
   let pingInterval = null;
   let isClosed = false;
+  const streamMetadata = new Map;
   const functionCalls = new Map;
   const openToolBlocks = new Set;
   const stream = new ReadableStream({
@@ -39337,6 +40132,13 @@ data: ${JSON.stringify(data)}
       };
       const closeTools = () => {
         for (const fnCall of openToolBlocks) {
+          if (fnCall.buffered && fnCall.arguments) {
+            send("content_block_delta", {
+              type: "content_block_delta",
+              index: fnCall.index,
+              delta: { type: "input_json_delta", partial_json: fnCall.arguments }
+            });
+          }
           send("content_block_stop", { type: "content_block_stop", index: fnCall.index });
         }
         openToolBlocks.clear();
@@ -39383,6 +40185,14 @@ data: ${JSON.stringify(data)}
             }
             try {
               const event = JSON.parse(data);
+              if (opts.middlewareManager) {
+                await opts.middlewareManager.afterStreamChunk({
+                  modelId: opts.modelName,
+                  chunk: event,
+                  delta: event,
+                  metadata: streamMetadata
+                });
+              }
               if (getLogLevel() === "debug" && event.type) {
                 log(`[ResponsesSSE] Event: ${event.type}`);
               }
@@ -39414,7 +40224,8 @@ data: ${JSON.stringify(data)}
                     name: fnName,
                     arguments: "",
                     index: curIdx++,
-                    claudeId: callId
+                    claudeId: callId,
+                    buffered: opts.shouldBufferTool?.(fnName) === true
                   };
                   functionCalls.set(openaiCallId, fnCallData);
                   if (itemId && itemId !== openaiCallId) {
@@ -39463,11 +40274,13 @@ data: ${JSON.stringify(data)}
                 const fnCall = functionCalls.get(callId);
                 if (fnCall) {
                   fnCall.arguments += event.delta || "";
-                  send("content_block_delta", {
-                    type: "content_block_delta",
-                    index: fnCall.index,
-                    delta: { type: "input_json_delta", partial_json: event.delta || "" }
-                  });
+                  if (!fnCall.buffered) {
+                    send("content_block_delta", {
+                      type: "content_block_delta",
+                      index: fnCall.index,
+                      delta: { type: "input_json_delta", partial_json: event.delta || "" }
+                    });
+                  }
                 }
               } else if (event.type === "response.output_item.done") {
                 if (event.item?.type === "reasoning" && event.item.encrypted_content) {
@@ -39482,6 +40295,23 @@ data: ${JSON.stringify(data)}
                   const callId = event.item.call_id || event.item.id;
                   const fnCall = functionCalls.get(callId) || functionCalls.get(event.item.id);
                   if (fnCall && openToolBlocks.has(fnCall)) {
+                    if (fnCall.buffered) {
+                      let finalArgs = fnCall.arguments;
+                      try {
+                        const repaired = opts.onToolCall?.(fnCall.name, finalArgs);
+                        if (typeof repaired === "string" && repaired !== finalArgs) {
+                          log(`[ResponsesSSE] tool call repaired: ${fnCall.name}`);
+                          finalArgs = repaired;
+                        }
+                      } catch (err) {
+                        log(`[ResponsesSSE] onToolCall threw for ${fnCall.name}: ${err}`);
+                      }
+                      send("content_block_delta", {
+                        type: "content_block_delta",
+                        index: fnCall.index,
+                        delta: { type: "input_json_delta", partial_json: finalArgs }
+                      });
+                    }
                     send("content_block_stop", { type: "content_block_stop", index: fnCall.index });
                     openToolBlocks.delete(fnCall);
                   }
@@ -39573,6 +40403,9 @@ data: ${JSON.stringify(data)}
         isClosed = true;
         if (opts.onTokenUpdate)
           opts.onTokenUpdate(inputTokens, outputTokens);
+        if (opts.middlewareManager) {
+          await opts.middlewareManager.afterStreamComplete(opts.modelName, streamMetadata);
+        }
         safeClose();
       } catch (error46) {
         if (pingInterval) {
@@ -39636,9 +40469,9 @@ var init_openai_responses_sse = __esm(() => {
 });
 
 // src/handlers/shared/token-tracker.ts
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir17 } from "os";
-import { join as join17 } from "path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir18 } from "os";
+import { dirname as dirname6, join as join18 } from "path";
 
 class TokenTracker {
   port;
@@ -39781,9 +40614,10 @@ class TokenTracker {
       if (this.quotaRemaining !== undefined) {
         data.quota_remaining = this.quotaRemaining;
       }
-      const claudishDir = join17(homedir17(), ".claudish");
-      mkdirSync9(claudishDir, { recursive: true });
-      writeFileSync10(join17(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+      const override = process.env.CLAUDISH_TOKEN_FILE;
+      const outPath = override || join18(homedir18(), ".claudish", `tokens-${this.port}.json`);
+      mkdirSync10(dirname6(outPath), { recursive: true });
+      writeFileSync10(outPath, JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -39809,6 +40643,7 @@ class ComposedHandler {
   explicitAdapter;
   modelAdapter;
   middlewareManager;
+  behaviorEngine;
   tokenTracker;
   targetModel;
   bareModelName;
@@ -39835,6 +40670,7 @@ class ComposedHandler {
       this.middlewareManager.register(new GeminiThoughtSignatureMiddleware);
     }
     this.middlewareManager.initialize().catch((err) => log(`[ComposedHandler:${this.bareModelName}] Middleware init error: ${err}`));
+    this.behaviorEngine = getBehaviorEngine();
     this.tokenTracker = new TokenTracker(port, {
       contextWindow: this.getModelContextWindow(),
       providerName: provider.name,
@@ -39947,6 +40783,22 @@ class ComposedHandler {
         log(`[${this.provider.displayName}] Tools: ${toolNames}`);
       }
     }
+    await this.middlewareManager.beforeRequest({
+      modelId: this.bareModelName,
+      messages,
+      tools,
+      stream: true,
+      claudeRequest,
+      claudeTools: claudeRequest.tools ?? []
+    });
+    const behaviorSession = this.behaviorEngine.startSession({
+      modelId: this.bareModelName,
+      providerName: this.provider.name,
+      isNativeAnthropic: /^claude[-.]/i.test(this.bareModelName) || this.provider.name === "anthropic"
+    });
+    if (!behaviorSession.isNoop) {
+      behaviorSession.applyRequest(claudeRequest, claudeRequest.tools ?? [], tools, messages);
+    }
     let requestPayload = adapter.buildPayload(claudeRequest, messages, tools);
     const extraFields = this.provider.getExtraPayloadFields?.();
     if (extraFields) {
@@ -39993,12 +40845,6 @@ class ComposedHandler {
     if (this.provider.transformPayload) {
       requestPayload = this.provider.transformPayload(requestPayload);
     }
-    await this.middlewareManager.beforeRequest({
-      modelId: this.bareModelName,
-      messages,
-      tools,
-      stream: true
-    });
     const endpoint = this.provider.getEndpoint(this.targetModel);
     const headers = await this.provider.getHeaders();
     headers["Content-Type"] = "application/json";
@@ -40280,7 +41126,7 @@ class ComposedHandler {
     };
     return this.handleStream(c, response, adapter, claudeRequest, toolNameMap, onStreamComplete, (code, message) => {
       streamApiError = { code, message };
-    });
+    }, behaviorSession);
   }
   async settleResponsesStreamHead(initial, reissue) {
     let response = initial;
@@ -40299,7 +41145,7 @@ class ComposedHandler {
         };
       }
       log(`[${this.provider.displayName}] in-stream ${verdict.code} before any output \u2014 ` + `retry ${attempt + 1}/${STREAM_RETRY_DELAYS_MS.length} in ${delayMs / 1000}s`);
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
       let next;
       try {
         next = await reissue();
@@ -40328,7 +41174,7 @@ class ComposedHandler {
   resolveStreamFormat() {
     return this.provider.overrideStreamFormat?.() ?? this.explicitAdapter?.getStreamFormat() ?? this.modelAdapter?.getStreamFormat() ?? this.getAdapter().getStreamFormat();
   }
-  handleStream(c, response, adapter, claudeRequest, toolNameMap, onComplete, onApiError) {
+  handleStream(c, response, adapter, claudeRequest, toolNameMap, onComplete, onApiError, behaviorSession) {
     let pendingOnComplete = onComplete;
     const onTokenUpdate = (input, output) => {
       const strategy = this.options.tokenStrategy || "standard";
@@ -40365,7 +41211,10 @@ class ComposedHandler {
           toolNameMap: adapter.getToolNameMap(),
           contextWindow: lookupModelForProvider(this.bareModelName, this.provider.name),
           onApiError,
-          priorInputTokens
+          priorInputTokens,
+          middlewareManager: this.middlewareManager,
+          shouldBufferTool: (name) => behaviorSession?.interceptsTool(name) ?? false,
+          onToolCall: (name, argsJson) => behaviorSession?.repairToolCall(name, argsJson) ?? null
         });
       case "anthropic-sse":
         return createAnthropicPassthroughStream(c, response, {
@@ -40461,6 +41310,7 @@ var STREAM_RETRY_DELAYS_MS;
 var init_composed_handler = __esm(() => {
   init_dialect_manager();
   init_logger();
+  init_behavior();
   init_middleware();
   init_openai();
   init_vision_proxy();
@@ -41258,12 +42108,6 @@ var init_api_key_map = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/zod@4.1.13/node_modules/zod/index.js
-var init_zod = __esm(() => {
-  init_external2();
-  init_external2();
-});
-
 // src/adapters/anthropic-api-format.ts
 var AnthropicAPIFormat;
 var init_anthropic_api_format = __esm(() => {
@@ -41541,7 +42385,7 @@ class AnthropicProviderTransport {
           delayMs = 500 * (attempt + 1);
         }
         log(`[${this.displayName}] 429 rate limited, retry ${attempt + 1}/${maxRetries} in ${(delayMs / 1000).toFixed(1)}s`);
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        await new Promise((resolve2) => setTimeout(resolve2, delayMs));
         continue;
       }
       return response;
@@ -41722,14 +42566,14 @@ async function discoverViaOllama(baseUrl, cacheKey) {
   let connectionError;
   let loadedRaw = [];
   try {
-    loadedRaw = await fetchOllamaModels(`${baseUrl}/api/ps`);
+    loadedRaw = await fetchOllamaModels2(`${baseUrl}/api/ps`);
   } catch (e) {
     connectionError = classifyFetchError(e, `${baseUrl}/api/ps`);
   }
   let allRaw = loadedRaw;
   if (allRaw.length === 0) {
     try {
-      allRaw = await fetchOllamaModels(`${baseUrl}/api/tags`);
+      allRaw = await fetchOllamaModels2(`${baseUrl}/api/tags`);
     } catch (e) {
       connectionError ??= classifyFetchError(e, `${baseUrl}/api/tags`);
     }
@@ -41840,7 +42684,7 @@ function extractLMStudioModels(body) {
   }
   return out;
 }
-async function fetchOllamaModels(url2) {
+async function fetchOllamaModels2(url2) {
   const response = await fetch(url2, {
     method: "GET",
     signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
@@ -42270,11 +43114,11 @@ var init_ollama_api_format = __esm(() => {
 });
 
 // src/providers/api-key-provenance.ts
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
-import { homedir as homedir18 } from "os";
-import { join as join18, resolve } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join19, resolve as resolve2 } from "path";
 function activeConfigPath() {
-  return activeGlobalConfigFile(join18(homedir18(), ".claudish", "config.json"));
+  return activeGlobalConfigFile(join19(homedir19(), ".claudish", "config.json"));
 }
 function configLayerLabel() {
   return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
@@ -42292,7 +43136,7 @@ function resolveApiKeyProvenance(envVar, aliases) {
   const allVars = [envVar, ...aliases || []];
   const dotenvValue = readDotenvKey(allVars);
   layers.push({
-    source: `.env (${resolve(".env")})`,
+    source: `.env (${resolve2(".env")})`,
     maskedValue: maskKey(dotenvValue),
     isActive: false
   });
@@ -42350,10 +43194,10 @@ function formatProvenanceLog(p) {
 }
 function readDotenvKey(envVars) {
   try {
-    const dotenvPath = resolve(".env");
+    const dotenvPath = resolve2(".env");
     if (!existsSync15(dotenvPath))
       return null;
-    const parsed = import_dotenv.parse(readFileSync12(dotenvPath, "utf-8"));
+    const parsed = import_dotenv.parse(readFileSync13(dotenvPath, "utf-8"));
     for (const v of envVars) {
       if (parsed[v])
         return parsed[v];
@@ -42368,7 +43212,7 @@ function readConfigKey(envVar) {
     const configPath = activeConfigPath();
     if (!existsSync15(configPath))
       return null;
-    const cfg = JSON.parse(readFileSync12(configPath, "utf-8"));
+    const cfg = JSON.parse(readFileSync13(configPath, "utf-8"));
     return cfg.apiKeys?.[envVar] || null;
   } catch {
     return null;
@@ -42407,10 +43251,10 @@ class GeminiRequestQueue {
       log(`[GeminiQueue] Queue full (${this.queue.length}/${this.maxQueueSize}), rejecting request`);
       throw new Error("Gemini request queue full. Please retry later.");
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const queuedRequest = {
         fetchFn,
-        resolve: resolve2,
+        resolve: resolve3,
         reject
       };
       this.queue.push(queuedRequest);
@@ -42466,7 +43310,7 @@ class GeminiRequestQueue {
     if (timeSinceLastRequest < delayMs) {
       const waitMs = delayMs - timeSinceLastRequest;
       log(`[GeminiQueue] Waiting ${waitMs}ms before next request`);
-      await new Promise((resolve2) => setTimeout(resolve2, waitMs));
+      await new Promise((resolve3) => setTimeout(resolve3, waitMs));
     }
   }
   handleRateLimitResponse(errorText) {
@@ -43264,10 +44108,10 @@ class LocalModelQueue {
       }
       throw new Error(`Local model queue full (${this.queue.length}/${this.maxQueueSize}). GPU is overloaded. Please wait for current requests to complete.`);
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const queuedRequest = {
         fetchFn,
-        resolve: resolve2,
+        resolve: resolve3,
         reject,
         providerId
       };
@@ -43362,7 +44206,7 @@ class LocalModelQueue {
     return parsed;
   }
   delay(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
   getStats() {
     return {
@@ -43664,10 +44508,10 @@ class OpenRouterRequestQueue {
       }
       throw new Error(`OpenRouter request queue full (${this.queue.length}/${this.maxQueueSize}). The API is rate-limited. Please wait and try again.`);
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const queuedRequest = {
         fetchFn,
-        resolve: resolve2,
+        resolve: resolve3,
         reject
       };
       this.queue.push(queuedRequest);
@@ -43735,7 +44579,7 @@ class OpenRouterRequestQueue {
       if (getLogLevel() === "debug") {
         log(`[OpenRouterQueue] Waiting ${waitMs}ms before next request`);
       }
-      await new Promise((resolve2) => setTimeout(resolve2, waitMs));
+      await new Promise((resolve3) => setTimeout(resolve3, waitMs));
     }
   }
   calculateDelay() {
@@ -43926,9 +44770,9 @@ var init_poe = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { existsSync as existsSync16, readFileSync as readFileSync13, statSync as statSync2 } from "fs";
-import { homedir as homedir19 } from "os";
-import { join as join19 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14, statSync as statSync3 } from "fs";
+import { homedir as homedir20 } from "os";
+import { join as join20 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -43968,10 +44812,10 @@ function loadDiskCache() {
   try {
     if (!existsSync16(CACHE_FILE))
       return false;
-    const stat = statSync2(CACHE_FILE);
+    const stat = statSync3(CACHE_FILE);
     const age = Date.now() - stat.mtimeMs;
     const isFresh = age < CACHE_TTL_MS2;
-    const raw2 = readFileSync13(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync14(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -43987,8 +44831,8 @@ var init_pricing_cache = __esm(() => {
   init_logger();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join19(homedir19(), ".claudish");
-  CACHE_FILE = join19(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join20(homedir20(), ".claudish");
+  CACHE_FILE = join20(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS2 = 24 * 60 * 60 * 1000;
 });
 
@@ -44009,6 +44853,13 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
   } catch (err) {
     log(`[Proxy] customEndpoints load skipped: ${err instanceof Error ? err.message : String(err)}`);
   }
+  try {
+    const hookRules2 = await loadHookRules(parseBehaviorConfig(loadConfig().behavior).hooks);
+    if (hookRules2.length > 0)
+      registerHookRules(hookRules2);
+  } catch (err) {
+    log(`[Proxy] behavior hooks load skipped: ${err instanceof Error ? err.message : String(err)}`);
+  }
   const nativeHandler = new NativeHandler(anthropicApiKey, options.advisorModels, options.advisorCollector);
   const openRouterHandlers = new Map;
   const localProviderHandlers = new Map;
@@ -44415,6 +45266,8 @@ var init_proxy_server = __esm(() => {
   init_model_loader();
   init_profile_config();
   init_api_key_map();
+  init_behavior();
+  init_hooks();
   init_custom_endpoints_loader();
   init_model_catalog_resolver();
   init_model_parser();
@@ -44435,6 +45288,175 @@ var init_proxy_server = __esm(() => {
   };
 });
 
+// src/team-stats.ts
+import { existsSync as existsSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "fs";
+import { join as join21 } from "path";
+function statsDir(sessionPath) {
+  return join21(sessionPath, "stats");
+}
+function tokenFileFor(sessionPath, anonId) {
+  return join21(statsDir(sessionPath), `${anonId}.json`);
+}
+function readTokenStats(sessionPath, anonId) {
+  const path = tokenFileFor(sessionPath, anonId);
+  if (!existsSync17(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync15(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function fmtTokens(n) {
+  if (!n || n <= 0)
+    return "0";
+  if (n < 1000)
+    return String(n);
+  if (n < 1e6)
+    return `${(n / 1000).toFixed(1)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function fmtCost(cost, isFree) {
+  if (isFree)
+    return "free";
+  if (cost === undefined || cost <= 0)
+    return "$0";
+  return `$${cost.toFixed(3)}`;
+}
+function fmtBytes(n) {
+  if (n <= 0)
+    return "0B";
+  if (n < 1024)
+    return `${n}B`;
+  if (n < 1024 * 1024)
+    return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+function fmtState(state) {
+  switch (state) {
+    case "COMPLETED":
+      return "done";
+    case "RUNNING":
+      return "run ";
+    case "FAILED":
+      return "FAIL";
+    case "TIMEOUT":
+      return "TIME";
+    case "EMPTY":
+      return "EMPT";
+    case "PENDING":
+      return "wait";
+    default:
+      return "?   ";
+  }
+}
+function renderTeamStats(sessionPath, manifest, status, opts) {
+  const nameWidth = opts.modelNameWidth ?? 18;
+  const ids = Object.keys(manifest.models).sort();
+  let done = 0;
+  let running = 0;
+  let failed = 0;
+  let totalTokens = 0;
+  let totalCost = 0;
+  let anyFree = false;
+  const rows = [];
+  for (const id of ids) {
+    const m = status.models[id];
+    if (!m)
+      continue;
+    const model = manifest.models[id]?.model ?? "unknown";
+    const stats = readTokenStats(sessionPath, id);
+    if (m.state === "COMPLETED")
+      done++;
+    else if (m.state === "RUNNING" || m.state === "PENDING")
+      running++;
+    else
+      failed++;
+    const inTok = stats?.input_tokens ?? 0;
+    const outTok = stats?.output_tokens ?? 0;
+    totalTokens += stats?.total_tokens ?? inTok + outTok;
+    totalCost += stats?.total_cost ?? 0;
+    if (stats?.is_free)
+      anyFree = true;
+    const name = model.length > nameWidth ? `${model.slice(0, nameWidth - 1)}\u2026` : model;
+    const bytes = m.outputSize > 0 ? fmtBytes(m.outputSize) : "";
+    const tokens = stats ? `${fmtTokens(inTok)}/${outTok > 0 ? fmtTokens(outTok) : "-"}` : "";
+    const cost = stats ? fmtCost(stats.total_cost, stats.is_free) : "";
+    rows.push(`  ${id} ${name.padEnd(nameWidth)} ${fmtState(m.state)} ` + `${bytes.padStart(7)} ${tokens.padStart(12)} ${cost.padStart(7)}`.trimEnd());
+  }
+  const parts = [`${ids.length} models`];
+  if (done)
+    parts.push(`${done} done`);
+  if (running)
+    parts.push(`${running} running`);
+  if (failed)
+    parts.push(`${failed} failed`);
+  parts.push(`${Math.round(opts.elapsedSeconds)}s`);
+  if (totalTokens > 0)
+    parts.push(`${fmtTokens(totalTokens)} tok`);
+  if (totalCost > 0 || anyFree)
+    parts.push(fmtCost(totalCost, anyFree && totalCost === 0));
+  return [`team: ${parts.join(", ")}`, ...rows].join(`
+`);
+}
+function renderTeamStatsCompact(sessionPath, manifest, status, opts) {
+  const ids = Object.keys(manifest.models).sort();
+  let done = 0;
+  let running = 0;
+  let failed = 0;
+  let totalTokens = 0;
+  let totalCost = 0;
+  const segs = [];
+  for (const id of ids) {
+    const m = status.models[id];
+    if (!m)
+      continue;
+    const model = manifest.models[id]?.model ?? "unknown";
+    const stats = readTokenStats(sessionPath, id);
+    if (m.state === "COMPLETED")
+      done++;
+    else if (m.state === "RUNNING" || m.state === "PENDING")
+      running++;
+    else
+      failed++;
+    totalTokens += stats?.total_tokens ?? 0;
+    totalCost += stats?.total_cost ?? 0;
+    const bits = [id, model, fmtState(m.state).trim()];
+    if (m.outputSize > 0)
+      bits.push(fmtBytes(m.outputSize));
+    else if (stats?.total_tokens)
+      bits.push(`${fmtTokens(stats.total_tokens)} tok`);
+    segs.push(bits.join(" "));
+  }
+  const counts = [];
+  if (done)
+    counts.push(`${done} done`);
+  if (running)
+    counts.push(`${running} run`);
+  if (failed)
+    counts.push(`${failed} fail`);
+  const head = [`team ${ids.length}: ${counts.join(" ") || "starting"}`];
+  head.push(`${Math.round(opts.elapsedSeconds)}s`);
+  if (totalTokens > 0)
+    head.push(`${fmtTokens(totalTokens)} tok`);
+  if (totalCost > 0)
+    head.push(fmtCost(totalCost));
+  let line1 = head.join(" \xB7 ");
+  if (line1.length > CHANNEL_LINE_BUDGET) {
+    line1 = line1.replace(/^team \d+: /, `t${ids.length}: `);
+  }
+  return `${line1}
+${segs.join(" \xB7 ")}`;
+}
+function writeStatusFile(sessionPath, manifest, status, opts) {
+  try {
+    writeFileSync11(join21(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+`, "utf-8");
+  } catch {}
+}
+var CHANNEL_LINE_BUDGET = 58;
+var init_team_stats = () => {};
+
 // src/team-orchestrator.ts
 var exports_team_orchestrator = {};
 __export(exports_team_orchestrator, {
@@ -44445,21 +45467,64 @@ __export(exports_team_orchestrator, {
   judgeResponses: () => judgeResponses,
   getStatus: () => getStatus,
   fisherYatesShuffle: () => fisherYatesShuffle,
+  classifyRunOutput: () => classifyRunOutput,
   buildJudgePrompt: () => buildJudgePrompt,
-  aggregateVerdict: () => aggregateVerdict
+  aggregateVerdict: () => aggregateVerdict,
+  STDOUT_TAIL_LIMIT: () => STDOUT_TAIL_LIMIT,
+  DEFAULT_MIN_OUTPUT_BYTES: () => DEFAULT_MIN_OUTPUT_BYTES
 });
 import { spawn as spawn2 } from "child_process";
 import {
   createWriteStream as createWriteStream2,
-  existsSync as existsSync17,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync14,
+  existsSync as existsSync18,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync16,
   readdirSync as readdirSync2,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "fs";
-import { join as join20, resolve as resolve2 } from "path";
+import { join as join22, resolve as resolve3 } from "path";
+function classifyRunOutput(opts) {
+  const { outputSize, stdoutTail, stderr, minOutputBytes } = opts;
+  const apiError = API_ERROR_RE.exec(stdoutTail);
+  if (apiError) {
+    return {
+      reason: "api_error",
+      detail: `Child exited 0 but stdout carries an API error: ${apiError[1]?.trim() || "unknown"}`
+    };
+  }
+  const bgCeiling = BG_CEILING_RE.exec(stderr);
+  if (bgCeiling) {
+    return {
+      reason: "background_task_ceiling",
+      detail: `Claude Code terminated the turn after ${bgCeiling[1]}s waiting on background tasks, ` + `flushing only partial output. Set CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=0 in the child ` + `environment to wait indefinitely, or tell the model not to spawn background work.`
+    };
+  }
+  const tailIsWholeOutput = outputSize <= STDOUT_TAIL_LIMIT;
+  if (outputSize === 0 || tailIsWholeOutput && stdoutTail.trim().length === 0) {
+    return {
+      reason: "empty_output",
+      detail: `Child exited 0 but produced no non-whitespace output (${outputSize} B).`
+    };
+  }
+  if (minOutputBytes > 0 && outputSize < minOutputBytes) {
+    return {
+      reason: "empty_output",
+      detail: `Child exited 0 but produced only ${outputSize} B of stdout ` + `(caller required at least ${minOutputBytes} B).`
+    };
+  }
+  return null;
+}
+function persistErrorLog(errorLogPath, header, stderr, stdoutTail) {
+  const parts = [`=== ${redactSecrets(header)} ===`, ""];
+  parts.push("--- stderr ---", stderr.trim() ? redactSecrets(stderr) : "(empty)", "");
+  parts.push("--- stdout (tail) ---", stdoutTail.trim() ? redactSecrets(stdoutTail) : "(empty)", "");
+  try {
+    writeFileSync12(errorLogPath, parts.join(`
+`), "utf-8");
+  } catch {}
+}
 function validateSessionPath(sessionPath) {
-  const resolved = resolve2(sessionPath);
+  const resolved = resolve3(sessionPath);
   const cwd = process.cwd();
   if (!resolved.startsWith(`${cwd}/`) && resolved !== cwd) {
     throw new Error(`Session path must be within current directory: ${sessionPath}`);
@@ -44478,18 +45543,18 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync17(join20(sessionPath, "manifest.json"))) {
+  if (existsSync18(join22(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. Use a new directory path or delete the existing session first.`);
   }
   const sentinels = models.filter(isSentinelModel);
   if (sentinels.length > 0) {
     throw new Error(`Invalid model(s) for team run: ${sentinels.join(", ")}. These are Claude Code agent selectors, not external model IDs. Use real external models (e.g., "gemini-2.0-flash", "gpt-4o", "or@deepseek/deepseek-r1"). For Claude models, use a Task agent instead of the team tool.`);
   }
-  mkdirSync10(join20(sessionPath, "work"), { recursive: true });
-  mkdirSync10(join20(sessionPath, "errors"), { recursive: true });
+  mkdirSync11(join22(sessionPath, "work"), { recursive: true });
+  mkdirSync11(join22(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync11(join20(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync17(join20(sessionPath, "input.md"))) {
+    writeFileSync12(join22(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync18(join22(sessionPath, "input.md"))) {
     throw new Error(`No input.md found at ${sessionPath} and no input provided`);
   }
   const ids = models.map((_, i) => String(i + 1).padStart(2, "0"));
@@ -44506,9 +45571,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync10(join20(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync11(join22(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync11(join20(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync12(join22(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -44522,22 +45587,25 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync11(join20(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync12(join22(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 async function runModels(sessionPath, opts = {}) {
   const timeoutMs = (opts.timeout ?? 300) * 1000;
-  const manifest = JSON.parse(readFileSync14(join20(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join20(sessionPath, "status.json");
-  const inputPath = join20(sessionPath, "input.md");
-  const inputContent = readFileSync14(inputPath, "utf-8");
+  const manifest = JSON.parse(readFileSync16(join22(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join22(sessionPath, "status.json");
+  const inputPath = join22(sessionPath, "input.md");
+  const inputContent = readFileSync16(inputPath, "utf-8");
   await prehydrateCredentialsForSpawn(Object.values(manifest.models).map((m) => m.model));
-  const statusCache = JSON.parse(readFileSync14(statusPath, "utf-8"));
+  const statusCache = JSON.parse(readFileSync16(statusPath, "utf-8"));
   function updateModelStatus(id, update) {
     statusCache.models[id] = { ...statusCache.models[id], ...update };
-    writeFileSync11(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
+    writeFileSync12(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
   }
+  const minOutputBytes = opts.minOutputBytes ?? DEFAULT_MIN_OUTPUT_BYTES;
+  mkdirSync11(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
+  const runtimes = new Map;
   const sigintHandler = () => {
     for (const [, proc] of processes) {
       if (!proc.killed)
@@ -44548,8 +45616,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join20(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join20(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join22(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join22(sessionPath, "errors", `${anonId}.log`);
     const args = ["--model", entry.model, "-y", "--stdin", "--quiet", ...opts.claudeFlags ?? []];
     updateModelStatus(anonId, {
       state: "RUNNING",
@@ -44557,11 +45625,17 @@ async function runModels(sessionPath, opts = {}) {
     });
     const proc = spawn2("claudish", args, {
       stdio: ["pipe", "pipe", "pipe"],
-      shell: false
+      shell: false,
+      env: {
+        ...process.env,
+        CLAUDISH_TOKEN_FILE: tokenFileFor(sessionPath, anonId)
+      }
     });
     let byteCount = 0;
+    let stdoutTail = "";
     proc.stdout?.on("data", (chunk) => {
       byteCount += chunk.length;
+      stdoutTail = (stdoutTail + chunk.toString()).slice(-STDOUT_TAIL_LIMIT);
     });
     const outputStream = createWriteStream2(outputPath);
     proc.stdout?.pipe(outputStream);
@@ -44569,9 +45643,17 @@ async function runModels(sessionPath, opts = {}) {
     proc.stderr?.on("data", (chunk) => {
       stderr += chunk.toString();
     });
+    const command = `claudish ${args.join(" ")}`;
+    runtimes.set(anonId, {
+      command,
+      errorLogPath,
+      getStderr: () => stderr,
+      getStdoutTail: () => stdoutTail,
+      getByteCount: () => byteCount
+    });
     proc.stdin?.write(inputContent);
     proc.stdin?.end();
-    const completionPromise = new Promise((resolve3) => {
+    const completionPromise = new Promise((resolve4) => {
       let exitCode = null;
       let resolved = false;
       const finish = () => {
@@ -44579,38 +45661,57 @@ async function runModels(sessionPath, opts = {}) {
           return;
         if (statusCache.models[anonId].state === "TIMEOUT") {
           resolved = true;
-          resolve3();
+          resolve4();
           return;
         }
         resolved = true;
         const outputSize = byteCount;
-        const failed = exitCode !== 0;
-        updateModelStatus(anonId, {
-          state: failed ? "FAILED" : "COMPLETED",
-          exitCode: exitCode ?? 1,
-          completedAt: new Date().toISOString(),
-          outputSize,
-          error: failed ? {
-            model: anonId,
-            command: `claudish ${args.join(" ")}`,
-            stderrSnippet: stderr ? stderr.slice(-2000) : undefined,
-            errorLogPath,
-            workDir: sessionPath
-          } : undefined
-        });
+        const crashed = exitCode !== 0;
+        const degraded = crashed ? null : classifyRunOutput({ outputSize, stdoutTail, stderr, minOutputBytes });
+        const failed = crashed || degraded !== null;
+        const state = crashed ? "FAILED" : degraded ? "EMPTY" : "COMPLETED";
+        if (failed) {
+          const reason = crashed ? "nonzero_exit" : degraded.reason;
+          const detail = crashed ? `Child exited with code ${exitCode}.` : degraded.detail;
+          persistErrorLog(errorLogPath, `${state}: ${detail}`, stderr, stdoutTail);
+          updateModelStatus(anonId, {
+            state,
+            exitCode: exitCode ?? 1,
+            completedAt: new Date().toISOString(),
+            outputSize,
+            error: {
+              model: anonId,
+              command,
+              reason,
+              detail,
+              stderrSnippet: stderr ? redactSecrets(stderr).slice(-2000) : undefined,
+              stdoutSnippet: stdoutTail ? redactSecrets(stdoutTail).slice(-2000) : undefined,
+              errorLogPath,
+              workDir: sessionPath
+            }
+          });
+        } else {
+          updateModelStatus(anonId, {
+            state,
+            exitCode: exitCode ?? 0,
+            completedAt: new Date().toISOString(),
+            outputSize,
+            error: undefined
+          });
+        }
         opts.onStatusChange?.(anonId, statusCache.models[anonId]);
-        resolve3();
+        resolve4();
       };
       outputStream.on("close", finish);
       proc.on("exit", (code) => {
         const current = statusCache.models[anonId];
         if (current?.state === "TIMEOUT") {
           resolved = true;
-          resolve3();
+          resolve4();
           return;
         }
         if (stderr) {
-          writeFileSync11(errorLogPath, stderr, "utf-8");
+          writeFileSync12(errorLogPath, redactSecrets(stderr), "utf-8");
         }
         exitCode = code;
         if (outputStream.destroyed) {
@@ -44621,29 +45722,79 @@ async function runModels(sessionPath, opts = {}) {
     processes.set(anonId, proc);
     completionPromises.push(completionPromise);
   }
+  const runStartedMs = Date.now();
+  const POLL_MS = 2000;
+  const heartbeatMs = (opts.heartbeatSeconds ?? 60) * 1000;
+  let lastSignature = "";
+  let lastEmitMs = 0;
+  const stateSignature = () => Object.entries(statusCache.models).sort(([a], [b]) => a.localeCompare(b)).map(([id, m]) => `${id}:${m.state}:${m.outputSize}`).join("|");
+  const emitProgress = (phase = "running") => {
+    const elapsedSeconds = (Date.now() - runStartedMs) / 1000;
+    writeStatusFile(sessionPath, manifest, statusCache, { elapsedSeconds });
+    if (!opts.onProgress)
+      return;
+    const signature = stateSignature();
+    const changed = signature !== lastSignature;
+    const heartbeatDue = Date.now() - lastEmitMs >= heartbeatMs;
+    if (phase !== "settled" && !changed && !heartbeatDue)
+      return;
+    lastSignature = signature;
+    lastEmitMs = Date.now();
+    try {
+      const models = Object.values(statusCache.models);
+      opts.onProgress({
+        rendered: renderTeamStatsCompact(sessionPath, manifest, statusCache, { elapsedSeconds }),
+        phase,
+        allFailed: models.length > 0 && models.every((m) => m.state !== "COMPLETED")
+      });
+    } catch {}
+  };
+  emitProgress();
+  const progressHandle = setInterval(() => emitProgress("running"), POLL_MS);
+  progressHandle.unref?.();
   let timeoutHandle = null;
   await Promise.race([
     Promise.all(completionPromises),
-    new Promise((resolve3) => {
+    new Promise((resolve4) => {
       timeoutHandle = setTimeout(() => {
         for (const [id, proc] of processes) {
           const current = statusCache.models[id];
           if (current.state === "RUNNING") {
             if (!proc.killed)
               proc.kill("SIGTERM");
+            const rt = runtimes.get(id);
+            const stderr = rt?.getStderr() ?? "";
+            const stdoutTail = rt?.getStdoutTail() ?? "";
+            const bytes = rt?.getByteCount() ?? 0;
+            const detail = `Killed by the orchestrator after ${timeoutMs / 1000}s with ${bytes} B of stdout. ` + `In --quiet print mode the child emits its answer only at the end, so 0 B means ` + `"did not finish", not "produced nothing".`;
+            if (rt)
+              persistErrorLog(rt.errorLogPath, `TIMEOUT: ${detail}`, stderr, stdoutTail);
             updateModelStatus(id, {
               state: "TIMEOUT",
-              completedAt: new Date().toISOString()
+              completedAt: new Date().toISOString(),
+              outputSize: bytes,
+              error: rt ? {
+                model: id,
+                command: rt.command,
+                reason: "timeout",
+                detail,
+                stderrSnippet: stderr ? redactSecrets(stderr).slice(-2000) : undefined,
+                stdoutSnippet: stdoutTail ? redactSecrets(stdoutTail).slice(-2000) : undefined,
+                errorLogPath: rt.errorLogPath,
+                workDir: sessionPath
+              } : undefined
             });
             opts.onStatusChange?.(id, statusCache.models[id]);
           }
         }
-        resolve3();
+        resolve4();
       }, timeoutMs);
     })
   ]);
   if (timeoutHandle !== null)
     clearTimeout(timeoutHandle);
+  clearInterval(progressHandle);
+  emitProgress("settled");
   process.off("SIGINT", sigintHandler);
   return statusCache;
 }
@@ -44655,23 +45806,23 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file2 of responseFiles) {
     const id = file2.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync14(join20(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync16(join22(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync14(join20(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync16(join22(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync11(join20(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync12(join22(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join20(sessionPath, "judging");
-  mkdirSync10(judgePath, { recursive: true });
+  const judgePath = join22(sessionPath, "judging");
+  mkdirSync11(judgePath, { recursive: true });
   setupSession(judgePath, judgeModels, judgePrompt);
   await runModels(judgePath, { claudeFlags: opts.claudeFlags });
   const votes = parseJudgeVotes(judgePath, Object.keys(responses));
   const verdict = aggregateVerdict(votes, Object.keys(responses));
-  writeFileSync11(join20(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync12(join22(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync14(join20(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync16(join22(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -44681,7 +45832,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync14(join20(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync16(join22(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -44744,7 +45895,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file2.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync14(join20(judgePath, file2), "utf-8");
+      content = readFileSync16(join22(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -44796,7 +45947,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync14(join20(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync16(join22(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -44827,9 +45978,13 @@ function formatVerdict(verdict, sessionPath) {
   }
   return output;
 }
-var SENTINEL_MODELS;
+var STDOUT_TAIL_LIMIT = 4000, API_ERROR_RE, BG_CEILING_RE, DEFAULT_MIN_OUTPUT_BYTES = 0, SENTINEL_MODELS;
 var init_team_orchestrator = __esm(() => {
   init_prehydrate();
+  init_redact();
+  init_team_stats();
+  API_ERROR_RE = /\[API Error:\s*([^\]]{0,300})\]/i;
+  BG_CEILING_RE = /Background tasks still running after (\d+)s; terminating/i;
   SENTINEL_MODELS = new Set([
     "internal",
     "default",
@@ -44844,16 +45999,17 @@ var exports_mcp_server = {};
 __export(exports_mcp_server, {
   startMcpServer: () => startMcpServer,
   runPromptViaProxy: () => runPromptViaProxy,
-  parseAnthropicSse: () => parseAnthropicSse
+  parseAnthropicSse: () => parseAnthropicSse,
+  formatTeamResult: () => formatTeamResult
 });
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync15, readdirSync as readdirSync3, writeFileSync as writeFileSync12 } from "fs";
-import { homedir as homedir20 } from "os";
-import { dirname as dirname5, join as join21 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync17, readdirSync as readdirSync3, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir21 } from "os";
+import { dirname as dirname7, join as join23 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
-  if (!forceRefresh && existsSync18(ALL_MODELS_CACHE_PATH2)) {
+  if (!forceRefresh && existsSync19(ALL_MODELS_CACHE_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync15(ALL_MODELS_CACHE_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync17(ALL_MODELS_CACHE_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const ageInDays = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
       if (ageInDays <= CACHE_MAX_AGE_DAYS) {
@@ -44867,12 +46023,12 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync11(CLAUDISH_CACHE_DIR, { recursive: true });
-    writeFileSync12(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
+    mkdirSync12(CLAUDISH_CACHE_DIR, { recursive: true });
+    writeFileSync13(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
-    if (existsSync18(ALL_MODELS_CACHE_PATH2)) {
-      const cacheData = JSON.parse(readFileSync15(ALL_MODELS_CACHE_PATH2, "utf-8"));
+    if (existsSync19(ALL_MODELS_CACHE_PATH2)) {
+      const cacheData = JSON.parse(readFileSync17(ALL_MODELS_CACHE_PATH2, "utf-8"));
       return cacheData.models || [];
     }
     return [];
@@ -44968,63 +46124,53 @@ function fuzzyScore(text, query) {
   }
   return queryIndex === lowerQuery.length ? score / lowerText.length : 0;
 }
+function fmtSize(n) {
+  if (n <= 0)
+    return "0B";
+  if (n < 1024)
+    return `${n}B`;
+  if (n < 1024 * 1024)
+    return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
 function formatTeamResult(status, sessionPath) {
-  const entries = Object.entries(status.models);
-  const failed = entries.filter(([, m]) => m.state === "FAILED" || m.state === "TIMEOUT");
+  const entries = Object.entries(status.models).sort(([a], [b]) => a.localeCompare(b));
+  const failed = entries.filter(([, m]) => m.state === "FAILED" || m.state === "TIMEOUT" || m.state === "EMPTY");
   const succeeded = entries.filter(([, m]) => m.state === "COMPLETED");
-  let result = JSON.stringify(status, null, 2);
+  const lines = [];
+  lines.push(`<<<TEAM_RESULT path="${sessionPath}">>>`);
+  lines.push(`status: ${failed.length === 0 ? "ok" : succeeded.length === 0 ? "all-failed" : "partial"}` + ` \u2014 ${succeeded.length}/${entries.length} succeeded`);
+  if (succeeded.length > 0) {
+    lines.push("succeeded:");
+    for (const [id, m] of succeeded) {
+      lines.push(`  ${id}  ${fmtSize(m.outputSize)}  response-${id}.md`);
+    }
+  }
   if (failed.length > 0) {
-    result += `
-
----
-## Failures Detected
-
-`;
-    result += `${succeeded.length}/${entries.length} models succeeded, ${failed.length} failed.
-
-`;
+    lines.push("failures:");
     for (const [id, m] of failed) {
-      result += `### Model ${id}: ${m.state}
-`;
-      if (m.error) {
-        result += `- **Model:** ${m.error.model}
-`;
-        result += `- **Command:** \`${m.error.command}\`
-`;
-        result += `- **Exit code:** ${m.exitCode}
-`;
-        if (m.error.stderrSnippet) {
-          result += `- **Error output:**
-\`\`\`
-${m.error.stderrSnippet}
-\`\`\`
-`;
-        }
-        result += `- **Full error log:** ${m.error.errorLogPath}
-`;
-        result += `- **Working directory:** ${m.error.workDir}
-`;
+      const reason = m.error?.reason ?? "unknown";
+      const next = NEXT_STEP[reason] ?? "read the evidence log";
+      lines.push(`  ${id}  ${m.state}  reason=${reason}`);
+      if (m.error?.detail)
+        lines.push(`      what: ${m.error.detail}`);
+      lines.push(`      next: ${next}`);
+      if (m.error?.errorLogPath) {
+        lines.push(`      evidence: ${m.error.errorLogPath}`);
+      } else {
+        lines.push("      evidence: NONE CAPTURED \u2014 orchestrator bug, report via report_error");
       }
-      result += `
-`;
     }
-    result += `---
-`;
-    result += "**To help claudish devs fix this**, use the `report_error` tool with:\n";
-    result += '- `error_type`: "provider_failure" or "team_failure"\n';
-    result += `- \`session_path\`: "${sessionPath}"
-`;
-    result += "- Copy the stderr snippet above into `stderr_snippet`\n";
-    result += "- Set `auto_send: true` to suggest enabling automatic reporting\n";
+    lines.push("actions:");
+    lines.push(`  full stderr/stdout for one failure  \u2192 Read the evidence path above`);
+    lines.push(`  machine-readable status             \u2192 team(mode="status", path="${sessionPath}")`);
+    lines.push(`  report a provider bug               \u2192 report_error(session_path="${sessionPath}")`);
   }
-  return result;
-}
-function sanitize(text) {
-  if (!text)
-    return "";
-  return text.replace(/sk-[a-zA-Z0-9_-]{10,}/g, "sk-***REDACTED***").replace(/Bearer [a-zA-Z0-9_.-]+/g, "Bearer ***REDACTED***").replace(/\/Users\/[^/\s]+/g, "/Users/***").replace(/\/home\/[^/\s]+/g, "/home/***").replace(/[A-Z_]+_API_KEY=[^\s]+/g, "***_API_KEY=REDACTED").replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, "***@***.***");
+  lines.push("<<<END_TEAM_RESULT>>>");
+  return lines.join(`
+`);
 }
-function defineTools(sessionManager) {
+function defineTools(sessionManager, notifyChannel) {
   const tools = [];
   tools.push({
     name: "run_prompt",
@@ -45355,12 +46501,25 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
         const input = args.input;
         const timeout = args.timeout;
         const resolved = validateSessionPath(path);
+        const teamSessionId = resolved.split("/").filter(Boolean).pop() ?? "team";
+        const teamCreatedAt = new Date().toISOString();
+        const runOpts = {
+          timeout,
+          onProgress: (u) => notifyChannel({
+            content: u.rendered,
+            sessionId: teamSessionId,
+            event: u.phase === "settled" ? u.allFailed ? "failed" : "completed" : "running",
+            model: "team",
+            elapsedSeconds: (Date.now() - Date.parse(teamCreatedAt)) / 1000,
+            createdAt: teamCreatedAt
+          })
+        };
         switch (mode) {
           case "run": {
             if (!models?.length)
               throw new Error("'models' is required for 'run' mode");
             setupSession(resolved, models, input);
-            const status = await runModels(resolved, { timeout });
+            const status = await runModels(resolved, runOpts);
             return {
               content: [{ type: "text", text: formatTeamResult(status, resolved) }]
             };
@@ -45373,7 +46532,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
             if (!models?.length)
               throw new Error("'models' is required for 'run-and-judge' mode");
             setupSession(resolved, models, input);
-            await runModels(resolved, { timeout });
+            await runModels(resolved, runOpts);
             const verdict = await judgeResponses(resolved, { judges });
             return { content: [{ type: "text", text: JSON.stringify(verdict, null, 2) }] };
           }
@@ -45436,7 +46595,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       let stderrFull = stderr_snippet || "";
       if (error_log_path) {
         try {
-          stderrFull = readFileSync15(error_log_path, "utf-8");
+          stderrFull = readFileSync17(error_log_path, "utf-8");
         } catch {}
       }
       const sessionData = {};
@@ -45444,16 +46603,16 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
         const sp = session_path;
         for (const file2 of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file2] = readFileSync15(join21(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync17(join23(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join21(sp, "errors");
-          if (existsSync18(errorDir)) {
+          const errorDir = join23(sp, "errors");
+          if (existsSync19(errorDir)) {
             for (const f of readdirSync3(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync15(join21(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync17(join23(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -45463,7 +46622,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
           for (const f of readdirSync3(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync15(join21(sp, f), "utf-8");
+                const content = readFileSync17(join23(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -45472,9 +46631,9 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join21(__dirname2, "../package.json");
-        if (existsSync18(pkgPath)) {
-          version2 = JSON.parse(readFileSync15(pkgPath, "utf-8")).version;
+        const pkgPath = join23(__dirname2, "../package.json");
+        if (existsSync19(pkgPath)) {
+          version2 = JSON.parse(readFileSync17(pkgPath, "utf-8")).version;
         }
       } catch {}
       const report = {
@@ -45759,7 +46918,31 @@ To report this error, use the report_error tool with error_type: "provider_failu
       watchNotificationResult(result, { sessionId: sessionId2, eventType: event.type });
     })
   });
-  const allTools = defineTools(sessionManager);
+  const channelEnabled = enabledGroups.has("channel");
+  const notifyChannel = (p) => {
+    if (!channelEnabled)
+      return;
+    try {
+      const result = server.notification({
+        method: "notifications/claude/channel",
+        params: {
+          content: p.content,
+          meta: {
+            session_id: p.sessionId,
+            event: p.event,
+            model: p.model,
+            elapsed_seconds: String(Math.round(p.elapsedSeconds)),
+            task_id: p.sessionId,
+            status: mapEventToTaskStatus(p.event),
+            created_at: p.createdAt,
+            last_updated_at: new Date().toISOString()
+          }
+        }
+      });
+      watchNotificationResult(result, { sessionId: p.sessionId, eventType: p.event });
+    } catch {}
+  };
+  const allTools = defineTools(sessionManager, notifyChannel);
   const enabledTools = allTools.filter((t) => enabledGroups.has(t.group));
   const toolMap = new Map(enabledTools.map((t) => [t.name, t]));
   console.error(`[claudish] MCP server started (tools: ${toolMode}, ${enabledTools.length} tools)`);
@@ -45830,7 +47013,7 @@ When channel mode is active, you receive <channel source="claudish" ...> notific
 5. Use list_sessions to see all active/completed sessions.
 6. Use cancel_session to stop a running session.
 
-The session_id in the channel tag's meta attributes is the key for all tool calls.`, proxyInstance = null, proxyStarting = null, EVENT_TO_TASK_STATUS;
+The session_id in the channel tag's meta attributes is the key for all tool calls.`, proxyInstance = null, proxyStarting = null, NEXT_STEP, sanitize, EVENT_TO_TASK_STATUS;
 var init_mcp_server = __esm(() => {
   init_server2();
   init_stdio2();
@@ -45840,15 +47023,24 @@ var init_mcp_server = __esm(() => {
   init_channel();
   init_model_loader();
   init_port_manager();
+  init_redact();
   init_provider_definitions();
   init_proxy_server();
   init_team_orchestrator();
   import_dotenv2 = __toESM(require_main(), 1);
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
-  __dirname2 = dirname5(__filename2);
-  CLAUDISH_CACHE_DIR = join21(homedir20(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join21(CLAUDISH_CACHE_DIR, "all-models.json");
+  __dirname2 = dirname7(__filename2);
+  CLAUDISH_CACHE_DIR = join23(homedir21(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join23(CLAUDISH_CACHE_DIR, "all-models.json");
+  NEXT_STEP = {
+    nonzero_exit: "read the evidence log, then retry or drop the model",
+    timeout: "raise `timeout`, or pick a faster model",
+    api_error: "retry once, or route via a different provider (or@<model>)",
+    background_task_ceiling: "set CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=0 for children, or forbid background work in the prompt",
+    empty_output: "retry once; if it repeats, drop the model"
+  };
+  sanitize = sanitizeForReport;
   EVENT_TO_TASK_STATUS = new Map([
     ["starting", "working"],
     ["running", "working"],
@@ -45865,7 +47057,7 @@ var exports_serve_command = {};
 __export(exports_serve_command, {
   serveCommand: () => serveCommand
 });
-import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
 function parseServeArgs(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -45884,12 +47076,12 @@ function parseServeArgs(args) {
   return out;
 }
 function loadModelMap(path) {
-  if (!existsSync19(path)) {
+  if (!existsSync20(path)) {
     throw new Error(`--models file not found: ${path}`);
   }
   let raw2;
   try {
-    raw2 = readFileSync16(path, "utf-8");
+    raw2 = readFileSync18(path, "utf-8");
   } catch (e) {
     throw new Error(`failed to read --models file ${path}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -47685,13 +48877,13 @@ var PromisePolyfill;
 var init_promise_polyfill = __esm(() => {
   PromisePolyfill = class PromisePolyfill extends Promise {
     static withResolver() {
-      let resolve3;
+      let resolve4;
       let reject;
       const promise3 = new Promise((res, rej) => {
-        resolve3 = res;
+        resolve4 = res;
         reject = rej;
       });
-      return { promise: promise3, resolve: resolve3, reject };
+      return { promise: promise3, resolve: resolve4, reject };
     }
   };
 });
@@ -47728,7 +48920,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise: promise3, resolve: resolve3, reject } = PromisePolyfill.withResolver();
+    const { promise: promise3, resolve: resolve4, reject } = PromisePolyfill.withResolver();
     const cancel = () => reject(new CancelPromptError);
     if (signal) {
       const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -47755,7 +48947,7 @@ function createPrompt(view) {
       cycle(() => {
         try {
           const nextView = view(config3, (value) => {
-            setImmediate(() => resolve3(value));
+            setImmediate(() => resolve4(value));
           });
           if (nextView === undefined) {
             const callerFilename = callSites[1]?.getFileName();
@@ -53596,7 +54788,7 @@ var require_lib2 = __commonJS((exports) => {
     return matches;
   };
   exports.analyse = analyse;
-  var detectFile = (filepath, opts = {}) => new Promise((resolve3, reject) => {
+  var detectFile = (filepath, opts = {}) => new Promise((resolve4, reject) => {
     let fd;
     const fs = (0, node_1.default)();
     const handler = (err, buffer) => {
@@ -53606,7 +54798,7 @@ var require_lib2 = __commonJS((exports) => {
       if (err) {
         reject(err);
       } else if (buffer) {
-        resolve3((0, exports.detect)(buffer));
+        resolve4((0, exports.detect)(buffer));
       } else {
         reject(new Error("No error and no buffer received"));
       }
@@ -57361,7 +58553,7 @@ var init_RemoveFileError = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+external-editor@2.0.1+04f2146be16c61ef/node_modules/@inquirer/external-editor/dist/index.js
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync17, unlinkSync as unlinkSync6, writeFileSync as writeFileSync13 } from "fs";
+import { readFileSync as readFileSync19, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
 import path from "path";
 import os from "os";
 import { randomUUID as randomUUID4 } from "crypto";
@@ -57470,14 +58662,14 @@ class ExternalEditor {
       if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
         opt.mode = this.fileOptions.mode;
       }
-      writeFileSync13(this.tempFile, this.text, opt);
+      writeFileSync14(this.tempFile, this.text, opt);
     } catch (createFileError) {
       throw new CreateFileError(createFileError);
     }
   }
   readTemporaryFile() {
     try {
-      const tempFileBuffer = readFileSync17(this.tempFile);
+      const tempFileBuffer = readFileSync19(this.tempFile);
       if (tempFileBuffer.length === 0) {
         this.text = "";
       } else {
@@ -58672,15 +59864,15 @@ async function geminiQuotaHandler() {
   }
 }
 async function codexQuotaHandler() {
-  const { readFileSync: readFileSync18, existsSync: existsSync20 } = await import("fs");
-  const { join: join22 } = await import("path");
-  const { homedir: homedir21 } = await import("os");
-  const credPath = join22(homedir21(), ".claudish", "codex-oauth.json");
-  if (!existsSync20(credPath)) {
+  const { readFileSync: readFileSync20, existsSync: existsSync21 } = await import("fs");
+  const { join: join24 } = await import("path");
+  const { homedir: homedir22 } = await import("os");
+  const credPath = join24(homedir22(), ".claudish", "codex-oauth.json");
+  if (!existsSync21(credPath)) {
     console.error(`${RED}No Codex credentials found.${R} Run: ${B}claudish login codex${R}`);
     process.exit(1);
   }
-  const creds = JSON.parse(readFileSync18(credPath, "utf-8"));
+  const creds = JSON.parse(readFileSync20(credPath, "utf-8"));
   let email3 = "";
   try {
     const parts = creds.access_token.split(".");
@@ -58732,9 +59924,9 @@ async function codexQuotaHandler() {
   }
   let modelSlugs = [];
   try {
-    const modelsPath = join22(homedir21(), ".codex", "models_cache.json");
-    if (existsSync20(modelsPath)) {
-      const cache2 = JSON.parse(readFileSync18(modelsPath, "utf-8"));
+    const modelsPath = join24(homedir22(), ".codex", "models_cache.json");
+    if (existsSync21(modelsPath)) {
+      const cache2 = JSON.parse(readFileSync20(modelsPath, "utf-8"));
       modelSlugs = (cache2.models || []).map((m) => m.slug || m.id).filter(Boolean);
     }
   } catch {}
@@ -58867,7 +60059,7 @@ __export(exports_config, {
   DEFAULT_PORT_RANGE: () => DEFAULT_PORT_RANGE
 });
 var DEFAULT_PORT_RANGE, ENV, OPENROUTER_API_URL2 = "https://openrouter.ai/api/v1/chat/completions", OPENROUTER_HEADERS;
-var init_config = __esm(() => {
+var init_config2 = __esm(() => {
   DEFAULT_PORT_RANGE = { start: 3000, end: 9000 };
   ENV = {
     OPENROUTER_API_KEY: "OPENROUTER_API_KEY",
@@ -59162,62 +60354,6 @@ var init_model_discovery = __esm(() => {
   _cache2 = new Map;
 });
 
-// src/providers/ollama-discovery.ts
-function ollamaBaseUrl() {
-  return process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
-}
-async function fetchOllamaModels2(options = {}) {
-  const { enrichCapabilities = true } = options;
-  const host = ollamaBaseUrl();
-  try {
-    const response = await fetch(`${host}/api/tags`, {
-      signal: AbortSignal.timeout(3000)
-    });
-    if (!response.ok)
-      return [];
-    const data = await response.json();
-    const models = data.models || [];
-    const enriched = await Promise.all(models.map(async (m) => {
-      let capabilities = [];
-      if (enrichCapabilities) {
-        try {
-          const showResponse = await fetch(`${host}/api/show`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ name: m.name }),
-            signal: AbortSignal.timeout(2000)
-          });
-          if (showResponse.ok) {
-            const showData = await showResponse.json();
-            capabilities = showData.capabilities || [];
-          }
-        } catch {}
-      }
-      const nameLower = String(m.name).toLowerCase();
-      const supportsTools = capabilities.includes("tools");
-      const isEmbeddingModel = capabilities.includes("embedding") || nameLower.includes("embed");
-      const sizeInfo = m.details?.parameter_size || "unknown size";
-      const toolsIndicator = supportsTools ? "\u2713 tools" : "\u2717 no tools";
-      return {
-        id: `ollama/${m.name}`,
-        name: m.name,
-        description: `Local Ollama model (${sizeInfo}, ${toolsIndicator})`,
-        provider: "ollama",
-        pricing: { prompt: "0", completion: "0" },
-        isLocal: true,
-        supportsTools,
-        isEmbeddingModel,
-        capabilities,
-        details: m.details,
-        size: m.size
-      };
-    }));
-    return enriched.filter((m) => !m.isEmbeddingModel);
-  } catch {
-    return [];
-  }
-}
-
 // src/model-selector.ts
 var exports_model_selector = {};
 __export(exports_model_selector, {
@@ -59749,7 +60885,7 @@ async function selectModelFromProvider(provider, tierName, recommendedModels, _f
     }
   }
   if (provider === "ollama") {
-    const ollamaModels = await fetchOllamaModels2({ enrichCapabilities: false });
+    const ollamaModels = await fetchOllamaModels({ enrichCapabilities: false });
     const chatModels = ollamaModels.map((m) => ({
       id: m.name,
       name: m.name,
@@ -60138,19 +61274,19 @@ async function probeLink(proxyUrl, link, timeoutMs) {
   }
   const streamResult = await consumeProbeStream(response, timeoutMs, startedAt);
   const totalMs = Date.now() - startedAt;
-  let timing;
+  let timing2;
   if (streamResult.state === "live" && streamResult.ttftMs !== undefined && !streamResult.truncated) {
     const ttftMs = streamResult.ttftMs;
     const tokens = streamResult.tokens ?? 0;
     const streamMs = Math.max(STREAM_MS_FLOOR, totalMs - ttftMs);
     const tokensPerSec = tokens > 0 ? tokens / streamMs * 1000 : 0;
-    timing = { ttfbMs, ttftMs, totalMs, tokens, tokensPerSec };
+    timing2 = { ttfbMs, ttftMs, totalMs, tokens, tokensPerSec };
   }
   const { ttftMs: _ttft, tokens: _tok, truncated: _trunc, ...rest } = streamResult;
   return annotateOAuthHint({
     ...rest,
     latencyMs: totalMs,
-    timing
+    timing: timing2
   }, link.provider, isOAuth);
 }
 function annotateOAuthHint(result, provider, isOAuth) {
@@ -60747,8 +61883,8 @@ function breakdownNum(ms) {
     return formatLatency(ms);
   return `${Math.round(Math.max(0, ms))}`;
 }
-function buildBarsLine(timing, scales, isFastest, usable) {
-  const t = timing;
+function buildBarsLine(timing2, scales, isFastest, usable) {
+  const t = timing2;
   const showTokBar = usable >= PRINTER_BARS_FULL_WIDTH;
   const showBreakdown = usable >= PRINTER_BARS_FULL_WIDTH || usable >= PRINTER_BARS_NOTOK_WIDTH;
   const barCells = timelineBarCells(t.totalMs, scales.maxTotalMs, PRINTER_BAR_WIDTH);
@@ -62688,8 +63824,8 @@ async function startProbeTui(initial) {
   });
   const store = new ProbeStore(initial);
   let resolveQuit;
-  const quitPromise = new Promise((resolve3) => {
-    resolveQuit = resolve3;
+  const quitPromise = new Promise((resolve4) => {
+    resolveQuit = resolve4;
   });
   let quit = false;
   const onQuit = () => {
@@ -62753,22 +63889,22 @@ __export(exports_cli, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync18,
+  existsSync as existsSync21,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync20,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "fs";
-import { homedir as homedir21 } from "os";
-import { dirname as dirname6, join as join22 } from "path";
+import { homedir as homedir22 } from "os";
+import { dirname as dirname8, join as join24 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join22(homedir21(), ".claudish");
-  if (!existsSync20(cacheDir))
+  const cacheDir = join24(homedir22(), ".claudish");
+  if (!existsSync21(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -62776,7 +63912,7 @@ function clearAllModelCaches() {
     const files = readdirSync4(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync7(join22(cacheDir, file2));
+        unlinkSync7(join24(cacheDir, file2));
         cleared++;
       }
     }
@@ -63186,15 +64322,15 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join22(homedir21(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync20(markerFile)) {
+      const markerFile = join24(homedir22(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync21(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
         }
         try {
-          mkdirSync12(dirname6(markerFile), { recursive: true });
-          writeFileSync14(markerFile, new Date().toISOString(), "utf-8");
+          mkdirSync13(dirname8(markerFile), { recursive: true });
+          writeFileSync15(markerFile, new Date().toISOString(), "utf-8");
         } catch {}
       }
     }
@@ -63300,7 +64436,7 @@ Local providers`);
   console.log(`  ${"\u2500".repeat(70)}`);
   let ollamaLine = "  Ollama:    not running";
   try {
-    const ollamaModels = await fetchOllamaModels2();
+    const ollamaModels = await fetchOllamaModels();
     if (ollamaModels.length > 0) {
       const toolCount = ollamaModels.filter((m) => m.supportsTools).length;
       ollamaLine = `  Ollama:    ${ollamaModels.length} models installed (${toolCount} with tools) \u2014 use: claudish --model ollama@<name>`;
@@ -64254,8 +65390,8 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join22(__dirname3, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync18(guidePath, "utf-8");
+    const guidePath = join24(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync20(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -64271,19 +65407,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join22(cwd, ".claude");
-  const skillsDir = join22(claudeDir, "skills");
-  const claudishSkillDir = join22(skillsDir, "claudish-usage");
-  const skillFile = join22(claudishSkillDir, "SKILL.md");
-  if (existsSync20(skillFile)) {
+  const claudeDir = join24(cwd, ".claude");
+  const skillsDir = join24(claudeDir, "skills");
+  const claudishSkillDir = join24(skillsDir, "claudish-usage");
+  const skillFile = join24(claudishSkillDir, "SKILL.md");
+  if (existsSync21(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join22(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync20(sourceSkillPath)) {
+  const sourceSkillPath = join24(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync21(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -64292,16 +65428,16 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync20(claudeDir)) {
-      mkdirSync12(claudeDir, { recursive: true });
+    if (!existsSync21(claudeDir)) {
+      mkdirSync13(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync20(skillsDir)) {
-      mkdirSync12(skillsDir, { recursive: true });
+    if (!existsSync21(skillsDir)) {
+      mkdirSync13(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync20(claudishSkillDir)) {
-      mkdirSync12(claudishSkillDir, { recursive: true });
+    if (!existsSync21(claudishSkillDir)) {
+      mkdirSync13(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync2(sourceSkillPath, skillFile);
@@ -64358,7 +65494,7 @@ function printAvailableModels() {
 }
 var __filename3, __dirname3;
 var init_cli = __esm(() => {
-  init_config();
+  init_config2();
   init_model_loader();
   init_model_selector();
   init_probe_results_printer();
@@ -64373,7 +65509,7 @@ var init_cli = __esm(() => {
   init_routing_rules();
   init_provider_resolver();
   __filename3 = fileURLToPath2(import.meta.url);
-  __dirname3 = dirname6(__filename3);
+  __dirname3 = dirname8(__filename3);
 });
 
 // src/update-checker.ts
@@ -64385,33 +65521,33 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync19, unlinkSync as unlinkSync8, writeFileSync as writeFileSync15 } from "fs";
-import { homedir as homedir22, platform as platform2, tmpdir } from "os";
-import { join as join23 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync21, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
+import { homedir as homedir23, platform as platform2, tmpdir } from "os";
+import { join as join25 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join23(homedir22(), "AppData", "Local");
-    cacheDir = join23(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join25(homedir23(), "AppData", "Local");
+    cacheDir = join25(localAppData, "claudish");
   } else {
-    cacheDir = join23(homedir22(), ".cache", "claudish");
+    cacheDir = join25(homedir23(), ".cache", "claudish");
   }
   try {
-    if (!existsSync21(cacheDir)) {
-      mkdirSync13(cacheDir, { recursive: true });
+    if (!existsSync22(cacheDir)) {
+      mkdirSync14(cacheDir, { recursive: true });
     }
-    return join23(cacheDir, "update-check.json");
+    return join25(cacheDir, "update-check.json");
   } catch {
-    return join23(tmpdir(), "claudish-update-check.json");
+    return join25(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync21(cachePath)) {
+    if (!existsSync22(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync19(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync21(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -64424,7 +65560,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync15(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync16(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache2) {
@@ -64434,7 +65570,7 @@ function isCacheValid(cache2) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync21(cachePath)) {
+    if (existsSync22(cachePath)) {
       unlinkSync8(cachePath);
     }
   } catch {}
@@ -64474,7 +65610,7 @@ async function fetchLatestVersionOrThrow(options = {}) {
     } catch (error46) {
       lastError = error46 instanceof Error && error46.name === "AbortError" ? new Error(`request timed out after ${timeoutMs}ms`) : error46 instanceof Error ? error46 : new Error(String(error46));
       if (attempt < retries) {
-        await new Promise((resolve3) => setTimeout(resolve3, 300 * (attempt + 1)));
+        await new Promise((resolve4) => setTimeout(resolve4, 300 * (attempt + 1)));
       }
     } finally {
       clearTimeout(timeout);
@@ -65313,15 +66449,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync20, writeFileSync as writeFileSync16 } from "fs";
-import { homedir as homedir23 } from "os";
-import { dirname as dirname7, join as join24 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync17 } from "fs";
+import { homedir as homedir24 } from "os";
+import { dirname as dirname9, join as join26 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
-  if (!existsSync22(path2))
+  if (!existsSync23(path2))
     return null;
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync20(path2, "utf-8"));
+    raw2 = JSON.parse(readFileSync22(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -65330,8 +66466,8 @@ function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   return raw2;
 }
 function writeProbeModelsCache(data, path2 = PROBE_MODELS_CACHE_PATH) {
-  mkdirSync14(dirname7(path2), { recursive: true });
-  writeFileSync16(path2, JSON.stringify(data), "utf-8");
+  mkdirSync15(dirname9(path2), { recursive: true });
+  writeFileSync17(path2, JSON.stringify(data), "utf-8");
 }
 function isCacheFresh(data, ttlMs = CACHE_TTL_MS4) {
   if (!data?.generatedAt)
@@ -65450,7 +66586,7 @@ function isValidResponse(raw2) {
 var PROBE_MODELS_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/probeModels", CACHE_TTL_MS4, FETCH_TIMEOUT_MS3 = 15000, PROBE_MODELS_CACHE_PATH, _inFlight = null;
 var init_probe_catalog = __esm(() => {
   CACHE_TTL_MS4 = 60 * 60 * 1000;
-  PROBE_MODELS_CACHE_PATH = join24(homedir23(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join26(homedir24(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -70207,14 +71343,14 @@ function App({ requestLogin } = {}) {
     return resolveSdkAuth({
       interactive: true,
       configAccount: readOnepasswordAccount(),
-      onNeedsPicker: (accounts) => new Promise((resolve3) => {
+      onNeedsPicker: (accounts) => new Promise((resolve4) => {
         setOpAccounts(accounts);
         setOpAccountCursor(0);
         opPickerResolver.current = (url2) => {
           if (url2?.trim())
             saveOnepasswordAccount(url2.trim(), "global");
           opPickerResolver.current = null;
-          resolve3(url2);
+          resolve4(url2);
         };
         setMode("pick_op_account");
       })
@@ -71660,8 +72796,8 @@ async function startConfigTui() {
   const renderer = await createCliRenderer2({
     exitOnCtrlC: false
   });
-  await new Promise((resolve3) => {
-    renderer.once("destroy", () => resolve3());
+  await new Promise((resolve4) => {
+    renderer.once("destroy", () => resolve4());
     createRoot2(renderer).render(/* @__PURE__ */ jsxDEV17(App, {
       requestLogin
     }, undefined, false, undefined, this));
@@ -71783,16 +72919,16 @@ __export(exports_claude_runner, {
 });
 import { spawn as spawn4 } from "child_process";
 import {
-  closeSync as closeSync4,
-  existsSync as existsSync23,
-  mkdirSync as mkdirSync15,
-  openSync as openSync4,
-  readFileSync as readFileSync21,
+  closeSync as closeSync5,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync16,
+  openSync as openSync5,
+  readFileSync as readFileSync23,
   unlinkSync as unlinkSync9,
-  writeFileSync as writeFileSync17
+  writeFileSync as writeFileSync18
 } from "fs";
-import { homedir as homedir24, tmpdir as tmpdir2 } from "os";
-import { join as join25 } from "path";
+import { homedir as homedir25, tmpdir as tmpdir2 } from "os";
+import { join as join27 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -71827,14 +72963,14 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join25(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join27(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
   }
   return "/etc/claude-code/managed-settings.json";
 }
-function managedSettingsForcesClaudeAi(readFile = readFileSync21) {
+function managedSettingsForcesClaudeAi(readFile = readFileSync23) {
   try {
     const raw2 = readFile(managedSettingsPath(), "utf-8");
     const parsed = JSON.parse(raw2);
@@ -71848,9 +72984,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join25(homeDir, ".claudish");
+  const claudishDir = join27(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join25(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join27(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -71942,18 +73078,18 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync17(scriptPath, script, "utf-8");
+  writeFileSync18(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join25(homeDir, ".claudish");
+  const claudishDir = join27(homeDir, ".claudish");
   try {
-    mkdirSync15(claudishDir, { recursive: true });
+    mkdirSync16(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join25(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join25(claudishDir, `tokens-${port}.json`);
+  const tempPath = join27(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join27(claudishDir, `tokens-${port}.json`);
   let statusCommand;
   if (isWindows2()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
@@ -71975,7 +73111,7 @@ function createTempSettingsFile(_modelDisplay, port, proxyAuthMode) {
     padding: 0
   };
   const settings = buildClaudishSettingsOverlay(statusLine, proxyAuthMode);
-  writeFileSync17(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync18(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine };
 }
 function buildClaudishSettingsOverlay(statusLine, proxyAuthMode) {
@@ -71996,7 +73132,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine, proxy
     if (userSettingsValue.trimStart().startsWith("{")) {
       userSettings = JSON.parse(userSettingsValue);
     } else {
-      const rawUserSettings = readFileSync21(userSettingsValue, "utf-8");
+      const rawUserSettings = readFileSync23(userSettingsValue, "utf-8");
       userSettings = JSON.parse(rawUserSettings);
     }
     userSettings.statusLine = statusLine;
@@ -72006,7 +73142,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine, proxy
     if (proxyAuthMode && !("forceLoginMethod" in userSettings)) {
       userSettings.forceLoginMethod = "console";
     }
-    writeFileSync17(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync18(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -72167,8 +73303,8 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir24();
-    const localPath = isWindows2() ? join25(home, ".claude", "local", "claude.exe") : join25(home, ".claude", "local", "claude");
+    const home = homedir25();
+    const localPath = isWindows2() ? join27(home, ".claude", "local", "claude.exe") : join27(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -72179,11 +73315,11 @@ Or set CLAUDE_PATH to your custom installation:`);
   const childWantsTty = config3.interactive && !process.stdout.isTTY && Boolean(process.stdin.isTTY);
   if (childWantsTty) {
     try {
-      const fd = openSync4("/dev/fd/0", "r+");
+      const fd = openSync5("/dev/fd/0", "r+");
       if (isatty(fd)) {
         ttyFd = fd;
       } else {
-        closeSync4(fd);
+        closeSync5(fd);
       }
     } catch {
       ttyFd = undefined;
@@ -72206,15 +73342,15 @@ Or set CLAUDE_PATH to your custom installation:`);
     const fdToClose = ttyFd;
     proc.on("spawn", () => {
       try {
-        closeSync4(fdToClose);
+        closeSync5(fdToClose);
       } catch {}
     });
   }
   setupSignalHandlers(proc, tempSettingsPath, config3.quiet, onCleanup);
-  const exitCode = await new Promise((resolve3) => {
+  const exitCode = await new Promise((resolve4) => {
     proc.on("exit", (code) => {
       setClaudeCodeRunning(false);
-      resolve3(code ?? 1);
+      resolve4(code ?? 1);
     });
   });
   releaseTerminalIsolation();
@@ -72248,23 +73384,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync23(process.env.CLAUDE_PATH)) {
+    if (existsSync24(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir24();
-  const localPath = isWindows3 ? join25(home, ".claude", "local", "claude.exe") : join25(home, ".claude", "local", "claude");
-  if (existsSync23(localPath)) {
+  const home = homedir25();
+  const localPath = isWindows3 ? join27(home, ".claude", "local", "claude.exe") : join27(home, ".claude", "local", "claude");
+  if (existsSync24(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join25(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join25(home, ".npm-global", "claude.cmd"),
-      join25(home, "node_modules", ".bin", "claude.cmd")
+      join27(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join27(home, ".npm-global", "claude.cmd"),
+      join27(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync23(path2)) {
+      if (existsSync24(path2)) {
         return path2;
       }
     }
@@ -72272,14 +73408,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join25(home, ".npm-global/bin/claude"),
-      join25(home, ".local/bin/claude"),
-      join25(home, "node_modules/.bin/claude"),
+      join27(home, ".npm-global/bin/claude"),
+      join27(home, ".local/bin/claude"),
+      join27(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join25(home, "../usr/bin/claude")
+      join27(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync23(path2)) {
+      if (existsSync24(path2)) {
         return path2;
       }
     }
@@ -72294,9 +73430,9 @@ async function findClaudeBinary() {
     proc.stdout?.on("data", (data) => {
       output += data.toString();
     });
-    const exitCode = await new Promise((resolve3) => {
+    const exitCode = await new Promise((resolve4) => {
       proc.on("exit", (code) => {
-        resolve3(code ?? 1);
+        resolve4(code ?? 1);
       });
     });
     if (exitCode === 0 && output.trim()) {
@@ -72319,7 +73455,7 @@ async function checkClaudeInstalled() {
 var restoreTerminal = null, MIN_AUTO_COMPACT_WINDOW = 200000;
 var init_claude_runner = __esm(() => {
   init_model_catalog();
-  init_config();
+  init_config2();
   init_logger();
   init_profile_config();
   init_model_discovery();
@@ -72336,18 +73472,18 @@ __export(exports_diag_output, {
   NullDiagOutput: () => NullDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync16, unlinkSync as unlinkSync10, writeFileSync as writeFileSync18 } from "fs";
-import { homedir as homedir25 } from "os";
-import { join as join26 } from "path";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync17, unlinkSync as unlinkSync10, writeFileSync as writeFileSync19 } from "fs";
+import { homedir as homedir26 } from "os";
+import { join as join28 } from "path";
 function getClaudishDir() {
-  const dir = join26(homedir25(), ".claudish");
+  const dir = join28(homedir26(), ".claudish");
   try {
-    mkdirSync16(dir, { recursive: true });
+    mkdirSync17(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join26(getClaudishDir(), `diag-${process.pid}.log`);
+  return join28(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -72356,7 +73492,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync18(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync19(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -72558,9 +73694,9 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn5 } from "child_process";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync24, writeFileSync as writeFileSync20 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname8, join as join27 } from "path";
+import { dirname as dirname10, join as join29 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveRouteInfo(modelId) {
@@ -72653,21 +73789,21 @@ function buildPaneHeader(model, prompt, bg) {
 }
 function findMagmuxBinary() {
   const thisFile = fileURLToPath3(import.meta.url);
-  const thisDir = dirname8(thisFile);
-  const pkgRoot = join27(thisDir, "..");
+  const thisDir = dirname10(thisFile);
+  const pkgRoot = join29(thisDir, "..");
   const platform3 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join27(pkgRoot, "native", `magmux-${platform3}-${arch}`);
-  if (existsSync24(bundledMagmux))
+  const bundledMagmux = join29(pkgRoot, "native", `magmux-${platform3}-${arch}`);
+  if (existsSync25(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform3}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join27(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync24(candidate))
+      const candidate = join29(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync25(candidate))
         return candidate;
-      const parent = dirname8(searchDir);
+      const parent = dirname10(searchDir);
       if (parent === searchDir)
         break;
       searchDir = parent;
@@ -72684,11 +73820,11 @@ function findMagmuxBinary() {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync24(sockPath)) {
+    if (existsSync25(sockPath)) {
       try {
-        client = await new Promise((resolve3, reject) => {
+        client = await new Promise((resolve4, reject) => {
           const s = netConnect(sockPath);
-          s.once("connect", () => resolve3(s));
+          s.once("connect", () => resolve4(s));
           s.once("error", reject);
         });
         break;
@@ -72699,7 +73835,7 @@ async function subscribeToMagmux(sockPath, onEvent) {
   if (!client) {
     return { results: null, client: null };
   }
-  return await new Promise((resolve3) => {
+  return await new Promise((resolve4) => {
     let buf = "";
     let finalResults = null;
     client.on("data", (chunk) => {
@@ -72722,7 +73858,7 @@ async function subscribeToMagmux(sockPath, onEvent) {
         } catch {}
       }
     });
-    const done = () => resolve3({ results: finalResults, client });
+    const done = () => resolve4({ results: finalResults, client });
     client.once("end", done);
     client.once("close", done);
     client.once("error", done);
@@ -72771,9 +73907,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join27(sessionPath, "gridfile.txt");
-  const prompt = readFileSync22(join27(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync22(join27(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join29(sessionPath, "gridfile.txt");
+  const prompt = readFileSync24(join29(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync24(join29(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -72784,7 +73920,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
     const header = buildPaneHeader(model, rawPrompt, bg);
     return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
   });
-  writeFileSync19(gridfilePath, `${gridLines.join(`
+  writeFileSync20(gridfilePath, `${gridLines.join(`
 `)}
 `, "utf-8");
   const magmuxPath = findMagmuxBinary();
@@ -72798,14 +73934,14 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const sockPath = `/tmp/magmux-${proc.pid}.sock`;
   const subscription = subscribeToMagmux(sockPath);
-  const procExit = new Promise((resolve3) => {
-    proc.on("exit", () => resolve3());
-    proc.on("error", () => resolve3());
+  const procExit = new Promise((resolve4) => {
+    proc.on("exit", () => resolve4());
+    proc.on("error", () => resolve4());
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join27(sessionPath, "status.json");
-  writeFileSync19(statusPath, JSON.stringify(status, null, 2), "utf-8");
+  const statusPath = join29(sessionPath, "status.json");
+  writeFileSync20(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
 var BANNER_BG_COLORS;
@@ -72828,8 +73964,8 @@ var init_team_grid = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync25, readFileSync as readFileSync23 } from "fs";
-import { join as join28, resolve as resolve3 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync25 } from "fs";
+import { join as join30, resolve as resolve4 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -72927,8 +74063,8 @@ async function applyOpImport() {
 async function applyConfigOverride() {
   const { planConfigOverride: planConfigOverride2, setConfigFileOverride: setConfigFileOverride2 } = await Promise.resolve().then(() => exports_config_override);
   const plan = planConfigOverride2(process.argv.slice(2), process.env, {
-    resolve: resolve3,
-    exists: existsSync25
+    resolve: resolve4,
+    exists: existsSync26
   });
   if (plan.kind === "none")
     return;
@@ -73036,7 +74172,7 @@ async function runCli() {
   const endImports = beginSpan("startup:cli-imports");
   const { checkClaudeInstalled: checkClaudeInstalled2, runClaudeWithProxy: runClaudeWithProxy2 } = await Promise.resolve().then(() => (init_claude_runner(), exports_claude_runner));
   const { parseArgs: parseArgs2, getVersion: getVersion4 } = await Promise.resolve().then(() => (init_cli(), exports_cli));
-  const { DEFAULT_PORT_RANGE: DEFAULT_PORT_RANGE2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+  const { DEFAULT_PORT_RANGE: DEFAULT_PORT_RANGE2 } = await Promise.resolve().then(() => (init_config2(), exports_config));
   const { selectModel: selectModel2, promptForApiKey: promptForApiKey2 } = await Promise.resolve().then(() => (init_model_selector(), exports_model_selector));
   const {
     resolveModelProvider: resolveModelProvider2,
@@ -73063,14 +74199,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync23(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync25(cliConfig.inputFile, "utf-8");
       }
       if (!prompt.trim()) {
         console.error("Error: --team requires a prompt (positional args or -f <file>)");
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join28(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join30(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         const { setupSession: setupSession2, runModels: runModels2 } = await Promise.resolve().then(() => (init_team_orchestrator(), exports_team_orchestrator));
         setupSession2(sessionPath, cliConfig.team, prompt);
@@ -73080,9 +74216,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join28(sessionPath, `response-${anonId}.md`);
+          const responsePath = join30(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync23(responsePath, "utf-8").trim();
+            const raw2 = readFileSync25(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {
@@ -73129,11 +74265,11 @@ Team Status`);
   You can disable it anytime with: --no-auto-approve
 
 `);
-          const answer = await new Promise((resolve4) => {
+          const answer = await new Promise((resolve5) => {
             const rl = createInterface2({ input: process.stdin, output: process.stderr });
             rl.question("Enable auto-approve? [Y/n] ", (ans) => {
               rl.close();
-              resolve4(ans.trim().toLowerCase());
+              resolve5(ans.trim().toLowerCase());
             });
           });
           const declined = answer === "n" || answer === "no";