claudish 7.23.0 → 7.25.0

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.23.0";
+var VERSION = "7.25.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -27006,6 +27006,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}`);
@@ -30418,11 +30421,550 @@ 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";
+function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
+  if (!existsSync12(path))
+    return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync9(path, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object")
+    return null;
+  const data = raw;
+  const lastUpdated = typeof data.lastUpdated === "string" ? data.lastUpdated : new Date(0).toISOString();
+  const models = Array.isArray(data.models) ? data.models : [];
+  const entries = Array.isArray(data.entries) ? data.entries : [];
+  return {
+    version: 2,
+    lastUpdated,
+    entries,
+    models
+  };
+}
+function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
+  const existing = readAllModelsCache(path);
+  const merged = {
+    version: 2,
+    lastUpdated: data.lastUpdated ?? new Date().toISOString(),
+    entries: data.entries ?? existing?.entries ?? [],
+    models: data.models ?? existing?.models ?? []
+  };
+  mkdirSync5(dirname4(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");
+});
+
+// src/adapters/model-catalog.ts
+function lookupModel(modelId, cachePath) {
+  const entry = findCacheEntry(modelId, cachePath);
+  if (!entry || entry.contextWindow === undefined)
+    return;
+  return {
+    modelId: entry.modelId,
+    contextWindow: entry.contextWindow,
+    supportsVision: entry.supportsVision
+  };
+}
+function lookupModelForProvider(modelId, provider, cachePath) {
+  const entry = findCacheEntry(modelId, cachePath);
+  if (!entry)
+    return;
+  return entry.aggregators?.find((a) => a.provider === provider)?.contextWindow ?? entry.contextWindow;
+}
+function resolveSubscriptionRouting(modelId, provider, cachePath) {
+  const entry = findCacheEntry(modelId, cachePath);
+  if (!entry)
+    return { kind: "unknown" };
+  if (entry.subscriptionPlans?.includes(provider)) {
+    const agg = entry.aggregators?.find((a) => a.provider === provider);
+    return agg?.externalId ? { kind: "serves", externalId: agg.externalId } : { kind: "unknown" };
+  }
+  return isSubscriptionPlan(provider, cachePath) ? { kind: "not-served" } : { kind: "unknown" };
+}
+function isSubscriptionPlan(provider, cachePath) {
+  const cache = readAllModelsCache(cachePath);
+  if (!cache)
+    return false;
+  return cache.entries.some((e) => e.subscriptionPlans?.includes(provider));
+}
+function findCacheEntry(modelId, cachePath) {
+  if (modelId.includes("@")) {
+    throw new Error(`model-catalog lookup received provider-routed ID "${modelId}" \u2014 callers must strip the "@" prefix before calling`);
+  }
+  const cache = readAllModelsCache(cachePath);
+  if (!cache || cache.entries.length === 0)
+    return;
+  const lower = modelId.toLowerCase();
+  const unprefixed = lower.includes("/") ? lower.substring(lower.lastIndexOf("/") + 1) : lower;
+  for (const entry of cache.entries) {
+    const entryId = entry.modelId.toLowerCase();
+    const exactMatch = entryId === unprefixed || entryId === lower;
+    const aliasMatch = entry.aliases?.some((a) => a.toLowerCase() === unprefixed || a.toLowerCase() === lower);
+    if (exactMatch || aliasMatch) {
+      return entry;
+    }
+  }
+  return;
+}
+var init_model_catalog = __esm(() => {
+  init_all_models_cache();
+});
+
+// src/providers/auto-route.ts
+var PROVIDER_TO_PREFIX, DISPLAY_NAMES;
+var init_auto_route = __esm(() => {
+  init_provider_definitions();
+  PROVIDER_TO_PREFIX = (() => {
+    const map3 = {};
+    for (const def of getAllProviders()) {
+      if (def.shortestPrefix) {
+        map3[def.name] = def.shortestPrefix;
+      }
+    }
+    return map3;
+  })();
+  DISPLAY_NAMES = (() => {
+    const map3 = {};
+    for (const def of getAllProviders()) {
+      map3[def.name] = def.displayName;
+    }
+    return map3;
+  })();
+});
+
+// src/providers/default-routing-rules.ts
+function validateRoutingRulesAgainstProviders(rules) {
+  const unknown3 = [];
+  for (const ruleKey of Object.keys(rules)) {
+    const entries = rules[ruleKey] ?? [];
+    for (const entry of entries) {
+      const atIdx = entry.indexOf("@");
+      const providerRaw = atIdx === -1 ? entry : entry.slice(0, atIdx);
+      const canonical = PROVIDER_SHORTCUTS[providerRaw.toLowerCase()] ?? providerRaw.toLowerCase();
+      if (!getProviderByName(canonical)) {
+        unknown3.push({ rule: ruleKey, entry, provider: canonical });
+      }
+    }
+  }
+  if (unknown3.length > 0) {
+    const lines = unknown3.map((u) => `  rule "${u.rule}" \u2192 entry "${u.entry}" \u2192 unknown provider "${u.provider}"`);
+    throw new Error(`[claudish] DEFAULT_ROUTING_RULES references unknown providers:
+${lines.join(`
+`)}`);
+  }
+}
+function validateDefaultRoutingRules() {
+  validateRoutingRulesAgainstProviders(DEFAULT_ROUTING_RULES);
+}
+var DEFAULT_ROUTING_RULES;
+var init_default_routing_rules = __esm(() => {
+  init_model_parser();
+  init_provider_definitions();
+  DEFAULT_ROUTING_RULES = {
+    "claude-*": ["native-anthropic", "openrouter"],
+    "gpt-*": ["openai-codex", "openai", "openrouter"],
+    "o1-*": ["openai-codex", "openai", "openrouter"],
+    "o3-*": ["openai-codex", "openai", "openrouter"],
+    "gemini-*": ["gemini-codeassist", "google", "openrouter"],
+    "grok-*": ["x-ai", "openrouter"],
+    "kimi-*": ["kimi-coding", "kimi", "openrouter"],
+    "k3*": ["kimi-coding", "kimi", "openrouter"],
+    "minimax-*": ["minimax-coding", "minimax", "openrouter"],
+    "glm-*": ["glm-coding", "glm", "openrouter"],
+    "z-ai-*": ["z-ai", "openrouter"],
+    "deepseek-*": ["deepseek", "openrouter"],
+    fugu: ["sakana-subscription", "sakana"],
+    "fugu-*": ["sakana-subscription", "sakana"],
+    "*-zen": ["opencode-zen"],
+    "*": ["openrouter"]
+  };
+  validateDefaultRoutingRules();
+});
+
+// src/providers/catalog-resolvers/openrouter.ts
+class OpenRouterCatalogResolver {
+  provider = "openrouter";
+  resolveSync(userInput) {
+    const entries = this._getEntries();
+    if (userInput.includes("/")) {
+      if (entries) {
+        for (const entry of entries) {
+          for (const src of Object.values(entry.sources)) {
+            if (src.externalId === userInput)
+              return userInput;
+          }
+        }
+      }
+      return userInput;
+    }
+    if (entries) {
+      const byModelId = entries.find((e) => e.modelId === userInput);
+      if (byModelId) {
+        const orId = this._getOpenRouterExternalId(byModelId);
+        if (orId)
+          return orId;
+      }
+      const byAlias = entries.find((e) => e.aliases.includes(userInput));
+      if (byAlias) {
+        const orId = this._getOpenRouterExternalId(byAlias);
+        if (orId)
+          return orId;
+      }
+      for (const entry of entries) {
+        for (const src of Object.values(entry.sources)) {
+          if (src.externalId === userInput) {
+            const orId = this._getOpenRouterExternalId(entry);
+            if (orId)
+              return orId;
+          }
+        }
+      }
+      const suffix = `/${userInput}`;
+      for (const entry of entries) {
+        const orId = this._getOpenRouterExternalId(entry);
+        if (orId?.endsWith(suffix))
+          return orId;
+      }
+      const lowerSuffix = `/${userInput.toLowerCase()}`;
+      for (const entry of entries) {
+        const orId = this._getOpenRouterExternalId(entry);
+        if (orId?.toLowerCase().endsWith(lowerSuffix))
+          return orId;
+      }
+    }
+    return null;
+  }
+  async warmCache() {
+    if (!_warmPromise) {
+      _warmPromise = this._fetchAndCache();
+    }
+    await _warmPromise;
+  }
+  isCacheWarm() {
+    return _memCache !== null && _memCache.length > 0;
+  }
+  async ensureReady(timeoutMs) {
+    if (this.isCacheWarm())
+      return;
+    if (!_warmPromise) {
+      _warmPromise = this._fetchAndCache();
+    }
+    await Promise.race([
+      _warmPromise,
+      new Promise((resolve) => setTimeout(resolve, timeoutMs))
+    ]);
+  }
+  async refreshCatalog(timeoutMs) {
+    let response;
+    try {
+      response = await fetch(FIREBASE_CATALOG_URL, {
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (err) {
+      const name = err?.name;
+      const reason = name === "TimeoutError" || name === "AbortError" ? "timeout" : "network";
+      return { kind: "fetch_failed", reason };
+    }
+    if (!response.ok) {
+      return { kind: "fetch_failed", reason: "http_error" };
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      return { kind: "fetch_failed", reason: "network" };
+    }
+    if (!Array.isArray(data.models) || data.models.length === 0) {
+      return { kind: "fetch_failed", reason: "empty" };
+    }
+    const backwardCompatModels = [];
+    for (const entry of data.models) {
+      const orSource = entry.sources["openrouter-api"];
+      if (orSource?.externalId) {
+        backwardCompatModels.push({ id: orSource.externalId });
+      }
+    }
+    _memCache = data.models;
+    writeAllModelsCache({
+      entries: data.models,
+      models: backwardCompatModels
+    });
+    _warmPromise = Promise.resolve();
+    return { kind: "refreshed", modelCount: data.models.length };
+  }
+  _getOpenRouterExternalId(entry) {
+    const orSource = entry.sources["openrouter-api"];
+    if (orSource?.externalId)
+      return orSource.externalId;
+    for (const src of Object.values(entry.sources)) {
+      if (src.externalId.includes("/"))
+        return src.externalId;
+    }
+    return null;
+  }
+  _getEntries() {
+    if (_memCache)
+      return _memCache;
+    const cache = readAllModelsCache();
+    if (!cache)
+      return null;
+    if (cache.entries.length > 0) {
+      _memCache = cache.entries;
+      return _memCache;
+    }
+    if (cache.models.length > 0) {
+      _memCache = cache.models.map((m) => ({
+        modelId: m.id.includes("/") ? m.id.split("/").slice(1).join("/") : m.id,
+        aliases: [],
+        sources: { "openrouter-api": { externalId: m.id } }
+      }));
+      return _memCache;
+    }
+    return null;
+  }
+  async _fetchAndCache() {
+    await this.refreshCatalog(8000);
+  }
+}
+var FIREBASE_CATALOG_URL, _memCache = null, _warmPromise = null;
+var init_openrouter = __esm(() => {
+  init_all_models_cache();
+  FIREBASE_CATALOG_URL = process.env.CLAUDISH_CATALOG_URL ?? process.env.FIREBASE_CATALOG_URL ?? "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels?status=active&catalog=slim&limit=1000";
+});
+
+// src/providers/model-catalog-resolver.ts
+function registerResolver(resolver) {
+  RESOLVER_REGISTRY.set(resolver.provider, resolver);
+}
+function getResolver(provider) {
+  return RESOLVER_REGISTRY.get(provider) ?? null;
+}
+function resolveModelNameSync(userInput, targetProvider) {
+  if (targetProvider !== "openrouter" && userInput.includes("/")) {
+    return { resolvedId: userInput, wasResolved: false, sourceLabel: "passthrough" };
+  }
+  const resolver = getResolver(targetProvider);
+  if (!resolver) {
+    return { resolvedId: userInput, wasResolved: false, sourceLabel: "passthrough" };
+  }
+  const resolved = resolver.resolveSync(userInput);
+  if (!resolved || resolved === userInput) {
+    return { resolvedId: userInput, wasResolved: false, sourceLabel: "passthrough" };
+  }
+  return {
+    resolvedId: resolved,
+    wasResolved: true,
+    sourceLabel: `${targetProvider} catalog`
+  };
+}
+function logResolution(userInput, result, quiet = false) {
+  if (result.wasResolved && !quiet) {
+    process.stderr.write(`[Model] Resolved "${userInput}" \u2192 "${result.resolvedId}" (${result.sourceLabel})
+`);
+  }
+}
+async function ensureCatalogReady(provider, timeoutMs = 5000) {
+  const resolver = getResolver(provider);
+  if (!resolver || resolver.isCacheWarm())
+    return;
+  await resolver.ensureReady(timeoutMs);
+}
+async function warmAllCatalogs(providers) {
+  const targets = providers ? [...RESOLVER_REGISTRY.entries()].filter(([k]) => providers.includes(k)) : [...RESOLVER_REGISTRY.entries()];
+  await Promise.allSettled(targets.map(([, r]) => r.warmCache()));
+}
+var RESOLVER_REGISTRY;
+var init_model_catalog_resolver = __esm(() => {
+  init_openrouter();
+  RESOLVER_REGISTRY = new Map;
+  [
+    new OpenRouterCatalogResolver
+  ].forEach(registerResolver);
+});
+
+// src/providers/routing-rules.ts
+function mergeRoutingRules(defaults, global_, local) {
+  return { ...defaults, ...global_, ...local };
+}
+function loadRoutingRules() {
+  const local = loadLocalConfig()?.routing ?? {};
+  const global_ = loadConfig().routing ?? {};
+  validateRoutingRules(local);
+  validateRoutingRules(global_);
+  return mergeRoutingRules(DEFAULT_ROUTING_RULES, global_, local);
+}
+function validateRoutingRules(rules) {
+  const seenLower = new Map;
+  for (const key of Object.keys(rules)) {
+    if (key !== "*" && (key.match(/\*/g) || []).length > 1) {
+      console.error(`[claudish] Warning: routing pattern "${key}" has multiple wildcards \u2014 only single * is supported. This pattern may not match as expected.`);
+    }
+    const lower = key.toLowerCase();
+    const prior = seenLower.get(lower);
+    if (prior !== undefined && prior !== key) {
+      console.error(`[claudish] Warning: routing patterns "${prior}" and "${key}" collide case-insensitively. Matching is case-insensitive, so one will silently shadow the other. Pick one casing and remove the duplicate.`);
+    } else {
+      seenLower.set(lower, key);
+    }
+  }
+}
+function matchRoutingRule(modelName, rules) {
+  const lowered = modelName.toLowerCase();
+  for (const [key, entries] of Object.entries(rules)) {
+    if (!key.includes("*") && key.toLowerCase() === lowered)
+      return entries;
+  }
+  const globKeys = Object.keys(rules).filter((k) => k !== "*" && k.includes("*")).sort((a, b) => b.length - a.length);
+  for (const pattern of globKeys) {
+    if (globMatch(pattern, modelName))
+      return rules[pattern];
+  }
+  if (rules["*"] !== undefined)
+    return rules["*"];
+  return null;
+}
+function buildRoutingChain(entries, originalModelName, cachePath) {
+  const routes = [];
+  for (const entry of entries) {
+    const atIdx = entry.indexOf("@");
+    let providerRaw;
+    let modelName;
+    if (atIdx !== -1) {
+      providerRaw = entry.slice(0, atIdx);
+      modelName = entry.slice(atIdx + 1);
+    } else {
+      providerRaw = entry;
+      modelName = originalModelName;
+    }
+    const provider = PROVIDER_SHORTCUTS[providerRaw.toLowerCase()] ?? providerRaw.toLowerCase();
+    if (atIdx === -1) {
+      const routing = resolveSubscriptionRouting(modelName, provider, cachePath);
+      if (routing.kind === "not-served")
+        continue;
+      if (routing.kind === "serves")
+        modelName = routing.externalId;
+    }
+    let modelSpec;
+    if (provider === "openrouter") {
+      const resolution = resolveModelNameSync(modelName, "openrouter");
+      modelSpec = resolution.resolvedId;
+    } else {
+      const prefix = PROVIDER_TO_PREFIX[provider] ?? provider;
+      modelSpec = `${prefix}@${modelName}`;
+    }
+    const displayName = DISPLAY_NAMES[provider] ?? provider;
+    routes.push({ provider, modelSpec, displayName });
+  }
+  return routes;
+}
+function globMatch(pattern, value) {
+  const star = pattern.indexOf("*");
+  const p = pattern.toLowerCase();
+  const v = value.toLowerCase();
+  if (star === -1)
+    return p === v;
+  const prefix = p.slice(0, star);
+  const suffix = p.slice(star + 1);
+  return v.startsWith(prefix) && v.endsWith(suffix) && v.length >= prefix.length + suffix.length;
+}
+async function hasCredentialsForProvider(provider) {
+  return credentials.isAvailable(provider);
+}
+async function routeExplicit(modelSpec, model, provider, cachePath) {
+  if (!await hasCredentialsForProvider(provider)) {
+    return {
+      kind: "no-route",
+      reason: `No credentials configured for "${provider}".`,
+      hint: buildCredentialHint(model, [provider]) ?? undefined
+    };
+  }
+  const built = buildRoutingChain([modelSpec], model, cachePath)[0];
+  if (!built) {
+    return {
+      kind: "no-route",
+      reason: `Could not build a route for "${modelSpec}".`
+    };
+  }
+  return { kind: "ok", primary: built, fallbacks: [] };
+}
+async function routeBare(model, nativeProvider, rules, defaultProvider, cachePath) {
+  const matched = matchRoutingRule(model, rules) ?? [];
+  const entries = [...matched];
+  if (defaultProvider && defaultProvider.length > 0) {
+    const canonicalDefault = PROVIDER_SHORTCUTS[defaultProvider.toLowerCase()] ?? defaultProvider.toLowerCase();
+    const alreadyPresent = entries.some((e) => {
+      const atIdx = e.indexOf("@");
+      const providerRaw = atIdx === -1 ? e : e.slice(0, atIdx);
+      const canonical = PROVIDER_SHORTCUTS[providerRaw.toLowerCase()] ?? providerRaw.toLowerCase();
+      return canonical === canonicalDefault;
+    });
+    if (!alreadyPresent)
+      entries.push(defaultProvider);
+  }
+  if (entries.length === 0) {
+    return {
+      kind: "no-route",
+      reason: `No routing rule matched "${model}".`,
+      hint: buildCredentialHint(model, [nativeProvider]) ?? undefined
+    };
+  }
+  const candidates = buildRoutingChain(entries, model, cachePath);
+  const credentialed = [];
+  const skipped = [];
+  const checks4 = await Promise.all(candidates.map((candidate) => hasCredentialsForProvider(candidate.provider)));
+  candidates.forEach((candidate, i) => {
+    if (checks4[i]) {
+      credentialed.push(candidate);
+    } else {
+      skipped.push(candidate.provider);
+    }
+  });
+  if (credentialed.length === 0) {
+    return {
+      kind: "no-route",
+      reason: skipped.length > 0 ? `No credentialed providers in chain for "${model}" (tried: ${skipped.join(", ")}).` : `No providers available for "${model}".`,
+      hint: buildCredentialHint(model, skipped) ?? undefined
+    };
+  }
+  const [primary, ...fallbacks] = credentialed;
+  return { kind: "ok", primary, fallbacks };
+}
+async function route(modelSpec, rulesOverride, defaultProviderOverride, cachePath) {
+  const parsed = parseModelSpec(modelSpec);
+  if (parsed.isExplicitProvider) {
+    return routeExplicit(modelSpec, parsed.model, parsed.provider, cachePath);
+  }
+  const rules = rulesOverride ?? loadRoutingRules();
+  const defaultProvider = defaultProviderOverride !== undefined ? defaultProviderOverride : rulesOverride !== undefined ? undefined : loadConfig().defaultProvider;
+  return routeBare(parsed.model, parsed.provider, rules, defaultProvider, cachePath);
+}
+var init_routing_rules = __esm(() => {
+  init_model_catalog();
+  init_authority();
+  init_profile_config();
+  init_auto_route();
+  init_default_routing_rules();
+  init_model_catalog_resolver();
+  init_model_parser();
+  init_model_parser();
+  init_routing_hints();
+});
+
 // src/providers/provider-resolver.ts
 var exports_provider_resolver = {};
 __export(exports_provider_resolver, {
   validateApiKeysForModels: () => validateApiKeysForModels,
   resolveModelProvider: () => resolveModelProvider,
+  rescueRoutableResolutions: () => rescueRoutableResolutions,
   requiresOpenRouterKey: () => requiresOpenRouterKey,
   isLocalModel: () => isLocalModel,
   getMissingKeysError: () => getMissingKeysError,
@@ -30594,8 +31136,20 @@ async function validateApiKeysForModels(models) {
       return;
     r.apiKeyAvailable = await credentials.isAvailable(r.catalogName);
   }));
+  await rescueRoutableResolutions(resolutions);
   return resolutions;
 }
+async function rescueRoutableResolutions(resolutions, router = route) {
+  await Promise.all(resolutions.map(async (r) => {
+    if (!r.requiredApiKeyEnvVar || r.apiKeyAvailable)
+      return;
+    try {
+      const plan = await router(r.fullModelId);
+      if (plan.kind === "ok")
+        r.apiKeyAvailable = true;
+    } catch {}
+  }));
+}
 function getMissingKeyResolutions(resolutions) {
   return resolutions.filter((r) => r.requiredApiKeyEnvVar && !r.apiKeyAvailable);
 }
@@ -30709,6 +31263,7 @@ var init_provider_resolver = __esm(() => {
   init_remote_provider_registry();
   init_onepassword();
   init_routing_hints();
+  init_routing_rules();
   API_KEY_INFO = new Proxy({}, {
     get(_target, prop) {
       return getApiKeyInfoForProvider(prop);
@@ -30990,9 +31545,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 mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join13 } from "path";
+import { createWriteStream, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join14 } from "path";
 
 class SessionManager {
   sessions = new Map;
@@ -31012,10 +31567,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 = join13(homedir13(), ".claudish", "sessions", sessionId);
-    mkdirSync5(sessionDir, { recursive: true });
+    const sessionDir = join14(homedir14(), ".claudish", "sessions", sessionId);
+    mkdirSync6(sessionDir, { recursive: true });
     if (opts.prompt) {
-      writeFileSync6(join13(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync7(join14(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     }
     const args = ["--model", opts.model, "-y", "--stdin", "--quiet", ...opts.claudishFlags ?? []];
     const proc = spawn("claudish", args, {
@@ -31042,7 +31597,7 @@ class SessionManager {
         });
       }
     });
-    const outputLogStream = createWriteStream(join13(sessionDir, "output.log"));
+    const outputLogStream = createWriteStream(join14(sessionDir, "output.log"));
     const entry = {
       info: {
         sessionId,
@@ -31089,9 +31644,9 @@ class SessionManager {
       watcher.processExited(code);
       outputLogStream.end();
       if (entry.stderr) {
-        writeFileSync6(join13(sessionDir, "stderr.log"), entry.stderr, "utf-8");
+        writeFileSync7(join14(sessionDir, "stderr.log"), entry.stderr, "utf-8");
       }
-      writeFileSync6(join13(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
+      writeFileSync7(join14(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
       this.cleanupSigint();
     });
     proc.on("error", (err) => {
@@ -31264,9 +31819,9 @@ var init_cache_ttl = __esm(() => {
 });
 
 // src/model-loader.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join14 } from "path";
+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";
 function groupRecommendedModels(entries) {
   const byId = new Map;
   for (const entry of entries) {
@@ -31362,9 +31917,9 @@ async function getRecommendedModels(opts = {}) {
   if (!forceRefresh && _cachedRecommendedModels) {
     return _cachedRecommendedModels;
   }
-  if (!forceRefresh && existsSync12(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (!forceRefresh && existsSync13(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync9(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync10(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -31380,9 +31935,9 @@ async function getRecommendedModels(opts = {}) {
       if (data.models && data.models.length > 0) {
         _cachedRecommendedModels = data;
         try {
-          const cacheDir = join14(homedir14(), ".claudish");
-          mkdirSync6(cacheDir, { recursive: true });
-          writeFileSync7(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
+          const cacheDir = join15(homedir15(), ".claudish");
+          mkdirSync7(cacheDir, { recursive: true });
+          writeFileSync8(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
         } catch {}
         return data;
       }
@@ -31393,9 +31948,9 @@ async function getRecommendedModels(opts = {}) {
 function getRecommendedModelsSync() {
   if (_cachedRecommendedModels)
     return _cachedRecommendedModels;
-  if (existsSync12(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (existsSync13(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync9(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync10(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -31519,7 +32074,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 = join14(homedir14(), ".claudish", "recommended-models-cache.json");
+  RECOMMENDED_MODELS_CACHE_PATH = join15(homedir15(), ".claudish", "recommended-models-cache.json");
   FIREBASE_SLUG_TO_PROVIDER_NAME = {
     openai: "openai",
     google: "google",
@@ -31986,10 +32541,10 @@ var init_request = __esm(() => {
       return this.#matchResult;
     }
     get matchedRoutes() {
-      return this.#matchResult[0].map(([[, route]]) => route);
+      return this.#matchResult[0].map(([[, route2]]) => route2);
     }
     get routePath() {
-      return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+      return this.#matchResult[0].map(([[, route2]]) => route2)[this.routeIndex].path;
     }
   };
 });
@@ -32637,7 +33192,7 @@ function buildMatcherFromPreprocessedRoutes(routes) {
   if (routes.length === 0) {
     return nullMatcher;
   }
-  const routesWithStaticPathFlag = routes.map((route) => [!/\*|\/:/.test(route[0]), ...route]).sort(([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
+  const routesWithStaticPathFlag = routes.map((route2) => [!/\*|\/:/.test(route2[0]), ...route2]).sort(([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
   const staticMap = /* @__PURE__ */ Object.create(null);
   for (let i = 0, j = -1, len = routesWithStaticPathFlag.length;i < len; i++) {
     const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
@@ -33283,104 +33838,6 @@ var init_remote_provider_types = __esm(() => {
   };
 });
 
-// src/providers/all-models-cache.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir15 } from "os";
-import { dirname as dirname4, join as join15 } from "path";
-function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
-  if (!existsSync13(path))
-    return null;
-  let raw2;
-  try {
-    raw2 = JSON.parse(readFileSync10(path, "utf-8"));
-  } catch {
-    return null;
-  }
-  if (!raw2 || typeof raw2 !== "object")
-    return null;
-  const data = raw2;
-  const lastUpdated = typeof data.lastUpdated === "string" ? data.lastUpdated : new Date(0).toISOString();
-  const models = Array.isArray(data.models) ? data.models : [];
-  const entries = Array.isArray(data.entries) ? data.entries : [];
-  return {
-    version: 2,
-    lastUpdated,
-    entries,
-    models
-  };
-}
-function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
-  const existing = readAllModelsCache(path);
-  const merged = {
-    version: 2,
-    lastUpdated: data.lastUpdated ?? new Date().toISOString(),
-    entries: data.entries ?? existing?.entries ?? [],
-    models: data.models ?? existing?.models ?? []
-  };
-  mkdirSync7(dirname4(path), { recursive: true });
-  writeFileSync8(path, JSON.stringify(merged), "utf-8");
-}
-var ALL_MODELS_CACHE_PATH;
-var init_all_models_cache = __esm(() => {
-  ALL_MODELS_CACHE_PATH = join15(homedir15(), ".claudish", "all-models.json");
-});
-
-// src/adapters/model-catalog.ts
-function lookupModel(modelId, cachePath) {
-  const entry = findCacheEntry(modelId, cachePath);
-  if (!entry || entry.contextWindow === undefined)
-    return;
-  return {
-    modelId: entry.modelId,
-    contextWindow: entry.contextWindow,
-    supportsVision: entry.supportsVision
-  };
-}
-function lookupModelForProvider(modelId, provider, cachePath) {
-  const entry = findCacheEntry(modelId, cachePath);
-  if (!entry)
-    return;
-  return entry.aggregators?.find((a) => a.provider === provider)?.contextWindow ?? entry.contextWindow;
-}
-function resolveSubscriptionRouting(modelId, provider, cachePath) {
-  const entry = findCacheEntry(modelId, cachePath);
-  if (!entry)
-    return { kind: "unknown" };
-  if (entry.subscriptionPlans?.includes(provider)) {
-    const agg = entry.aggregators?.find((a) => a.provider === provider);
-    return agg?.externalId ? { kind: "serves", externalId: agg.externalId } : { kind: "unknown" };
-  }
-  return isSubscriptionPlan(provider, cachePath) ? { kind: "not-served" } : { kind: "unknown" };
-}
-function isSubscriptionPlan(provider, cachePath) {
-  const cache = readAllModelsCache(cachePath);
-  if (!cache)
-    return false;
-  return cache.entries.some((e) => e.subscriptionPlans?.includes(provider));
-}
-function findCacheEntry(modelId, cachePath) {
-  if (modelId.includes("@")) {
-    throw new Error(`model-catalog lookup received provider-routed ID "${modelId}" \u2014 callers must strip the "@" prefix before calling`);
-  }
-  const cache = readAllModelsCache(cachePath);
-  if (!cache || cache.entries.length === 0)
-    return;
-  const lower = modelId.toLowerCase();
-  const unprefixed = lower.includes("/") ? lower.substring(lower.lastIndexOf("/") + 1) : lower;
-  for (const entry of cache.entries) {
-    const entryId = entry.modelId.toLowerCase();
-    const exactMatch = entryId === unprefixed || entryId === lower;
-    const aliasMatch = entry.aliases?.some((a) => a.toLowerCase() === unprefixed || a.toLowerCase() === lower);
-    if (exactMatch || aliasMatch) {
-      return entry;
-    }
-  }
-  return;
-}
-var init_model_catalog = __esm(() => {
-  init_all_models_cache();
-});
-
 // src/adapters/tool-name-utils.ts
 function hashToolName(name) {
   let h1 = 3735928559;
@@ -36336,6 +36793,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 = [];
@@ -36658,7 +37664,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;
@@ -37377,11 +38383,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";
@@ -38122,8 +39128,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 {
@@ -38852,6 +39858,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({
@@ -38883,6 +39890,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();
@@ -38929,6 +39943,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}`);
               }
@@ -38960,7 +39982,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) {
@@ -39009,11 +40032,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) {
@@ -39028,6 +40053,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);
                   }
@@ -39119,6 +40161,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) {
@@ -39355,6 +40400,7 @@ class ComposedHandler {
   explicitAdapter;
   modelAdapter;
   middlewareManager;
+  behaviorEngine;
   tokenTracker;
   targetModel;
   bareModelName;
@@ -39381,6 +40427,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,
@@ -39493,6 +40540,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) {
@@ -39539,12 +40602,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";
@@ -39826,7 +40883,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;
@@ -39845,7 +40902,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();
@@ -39874,7 +40931,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";
@@ -39911,7 +40968,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, {
@@ -40007,6 +41067,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();
@@ -40151,207 +41212,6 @@ var init_fallback_handler = __esm(() => {
   init_composed_handler();
 });
 
-// src/providers/catalog-resolvers/openrouter.ts
-class OpenRouterCatalogResolver {
-  provider = "openrouter";
-  resolveSync(userInput) {
-    const entries = this._getEntries();
-    if (userInput.includes("/")) {
-      if (entries) {
-        for (const entry of entries) {
-          for (const src of Object.values(entry.sources)) {
-            if (src.externalId === userInput)
-              return userInput;
-          }
-        }
-      }
-      return userInput;
-    }
-    if (entries) {
-      const byModelId = entries.find((e) => e.modelId === userInput);
-      if (byModelId) {
-        const orId = this._getOpenRouterExternalId(byModelId);
-        if (orId)
-          return orId;
-      }
-      const byAlias = entries.find((e) => e.aliases.includes(userInput));
-      if (byAlias) {
-        const orId = this._getOpenRouterExternalId(byAlias);
-        if (orId)
-          return orId;
-      }
-      for (const entry of entries) {
-        for (const src of Object.values(entry.sources)) {
-          if (src.externalId === userInput) {
-            const orId = this._getOpenRouterExternalId(entry);
-            if (orId)
-              return orId;
-          }
-        }
-      }
-      const suffix = `/${userInput}`;
-      for (const entry of entries) {
-        const orId = this._getOpenRouterExternalId(entry);
-        if (orId?.endsWith(suffix))
-          return orId;
-      }
-      const lowerSuffix = `/${userInput.toLowerCase()}`;
-      for (const entry of entries) {
-        const orId = this._getOpenRouterExternalId(entry);
-        if (orId?.toLowerCase().endsWith(lowerSuffix))
-          return orId;
-      }
-    }
-    return null;
-  }
-  async warmCache() {
-    if (!_warmPromise) {
-      _warmPromise = this._fetchAndCache();
-    }
-    await _warmPromise;
-  }
-  isCacheWarm() {
-    return _memCache !== null && _memCache.length > 0;
-  }
-  async ensureReady(timeoutMs) {
-    if (this.isCacheWarm())
-      return;
-    if (!_warmPromise) {
-      _warmPromise = this._fetchAndCache();
-    }
-    await Promise.race([
-      _warmPromise,
-      new Promise((resolve) => setTimeout(resolve, timeoutMs))
-    ]);
-  }
-  async refreshCatalog(timeoutMs) {
-    let response;
-    try {
-      response = await fetch(FIREBASE_CATALOG_URL, {
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-    } catch (err) {
-      const name = err?.name;
-      const reason = name === "TimeoutError" || name === "AbortError" ? "timeout" : "network";
-      return { kind: "fetch_failed", reason };
-    }
-    if (!response.ok) {
-      return { kind: "fetch_failed", reason: "http_error" };
-    }
-    let data;
-    try {
-      data = await response.json();
-    } catch {
-      return { kind: "fetch_failed", reason: "network" };
-    }
-    if (!Array.isArray(data.models) || data.models.length === 0) {
-      return { kind: "fetch_failed", reason: "empty" };
-    }
-    const backwardCompatModels = [];
-    for (const entry of data.models) {
-      const orSource = entry.sources["openrouter-api"];
-      if (orSource?.externalId) {
-        backwardCompatModels.push({ id: orSource.externalId });
-      }
-    }
-    _memCache = data.models;
-    writeAllModelsCache({
-      entries: data.models,
-      models: backwardCompatModels
-    });
-    _warmPromise = Promise.resolve();
-    return { kind: "refreshed", modelCount: data.models.length };
-  }
-  _getOpenRouterExternalId(entry) {
-    const orSource = entry.sources["openrouter-api"];
-    if (orSource?.externalId)
-      return orSource.externalId;
-    for (const src of Object.values(entry.sources)) {
-      if (src.externalId.includes("/"))
-        return src.externalId;
-    }
-    return null;
-  }
-  _getEntries() {
-    if (_memCache)
-      return _memCache;
-    const cache2 = readAllModelsCache();
-    if (!cache2)
-      return null;
-    if (cache2.entries.length > 0) {
-      _memCache = cache2.entries;
-      return _memCache;
-    }
-    if (cache2.models.length > 0) {
-      _memCache = cache2.models.map((m) => ({
-        modelId: m.id.includes("/") ? m.id.split("/").slice(1).join("/") : m.id,
-        aliases: [],
-        sources: { "openrouter-api": { externalId: m.id } }
-      }));
-      return _memCache;
-    }
-    return null;
-  }
-  async _fetchAndCache() {
-    await this.refreshCatalog(8000);
-  }
-}
-var FIREBASE_CATALOG_URL, _memCache = null, _warmPromise = null;
-var init_openrouter = __esm(() => {
-  init_all_models_cache();
-  FIREBASE_CATALOG_URL = process.env.CLAUDISH_CATALOG_URL ?? process.env.FIREBASE_CATALOG_URL ?? "https://us-central1-claudish-6da10.cloudfunctions.net/queryModels?status=active&catalog=slim&limit=1000";
-});
-
-// src/providers/model-catalog-resolver.ts
-function registerResolver(resolver) {
-  RESOLVER_REGISTRY.set(resolver.provider, resolver);
-}
-function getResolver(provider) {
-  return RESOLVER_REGISTRY.get(provider) ?? null;
-}
-function resolveModelNameSync(userInput, targetProvider) {
-  if (targetProvider !== "openrouter" && userInput.includes("/")) {
-    return { resolvedId: userInput, wasResolved: false, sourceLabel: "passthrough" };
-  }
-  const resolver = getResolver(targetProvider);
-  if (!resolver) {
-    return { resolvedId: userInput, wasResolved: false, sourceLabel: "passthrough" };
-  }
-  const resolved = resolver.resolveSync(userInput);
-  if (!resolved || resolved === userInput) {
-    return { resolvedId: userInput, wasResolved: false, sourceLabel: "passthrough" };
-  }
-  return {
-    resolvedId: resolved,
-    wasResolved: true,
-    sourceLabel: `${targetProvider} catalog`
-  };
-}
-function logResolution(userInput, result, quiet = false) {
-  if (result.wasResolved && !quiet) {
-    process.stderr.write(`[Model] Resolved "${userInput}" \u2192 "${result.resolvedId}" (${result.sourceLabel})
-`);
-  }
-}
-async function ensureCatalogReady(provider, timeoutMs = 5000) {
-  const resolver = getResolver(provider);
-  if (!resolver || resolver.isCacheWarm())
-    return;
-  await resolver.ensureReady(timeoutMs);
-}
-async function warmAllCatalogs(providers) {
-  const targets = providers ? [...RESOLVER_REGISTRY.entries()].filter(([k]) => providers.includes(k)) : [...RESOLVER_REGISTRY.entries()];
-  await Promise.allSettled(targets.map(([, r]) => r.warmCache()));
-}
-var RESOLVER_REGISTRY;
-var init_model_catalog_resolver = __esm(() => {
-  init_openrouter();
-  RESOLVER_REGISTRY = new Map;
-  [
-    new OpenRouterCatalogResolver
-  ].forEach(registerResolver);
-});
-
 // src/handlers/native-handler-advisor.ts
 import { appendFileSync as appendFileSync3 } from "fs";
 function loadAdvisorSwapConfig(cliModels, cliCollector) {
@@ -41005,12 +41865,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(() => {
@@ -41288,7 +42142,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;
@@ -41469,14 +42323,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`);
     }
@@ -41587,7 +42441,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)
@@ -42019,7 +42873,7 @@ 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 { join as join18, resolve as resolve2 } from "path";
 function activeConfigPath() {
   return activeGlobalConfigFile(join18(homedir18(), ".claudish", "config.json"));
 }
@@ -42039,7 +42893,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
   });
@@ -42097,7 +42951,7 @@ 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"));
@@ -42154,10 +43008,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);
@@ -42213,7 +43067,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) {
@@ -42958,245 +43812,6 @@ var init_provider_profiles = __esm(() => {
   };
 });
 
-// src/providers/auto-route.ts
-var PROVIDER_TO_PREFIX, DISPLAY_NAMES;
-var init_auto_route = __esm(() => {
-  init_provider_definitions();
-  PROVIDER_TO_PREFIX = (() => {
-    const map3 = {};
-    for (const def of getAllProviders()) {
-      if (def.shortestPrefix) {
-        map3[def.name] = def.shortestPrefix;
-      }
-    }
-    return map3;
-  })();
-  DISPLAY_NAMES = (() => {
-    const map3 = {};
-    for (const def of getAllProviders()) {
-      map3[def.name] = def.displayName;
-    }
-    return map3;
-  })();
-});
-
-// src/providers/default-routing-rules.ts
-function validateRoutingRulesAgainstProviders(rules) {
-  const unknown3 = [];
-  for (const ruleKey of Object.keys(rules)) {
-    const entries = rules[ruleKey] ?? [];
-    for (const entry of entries) {
-      const atIdx = entry.indexOf("@");
-      const providerRaw = atIdx === -1 ? entry : entry.slice(0, atIdx);
-      const canonical = PROVIDER_SHORTCUTS[providerRaw.toLowerCase()] ?? providerRaw.toLowerCase();
-      if (!getProviderByName(canonical)) {
-        unknown3.push({ rule: ruleKey, entry, provider: canonical });
-      }
-    }
-  }
-  if (unknown3.length > 0) {
-    const lines = unknown3.map((u) => `  rule "${u.rule}" \u2192 entry "${u.entry}" \u2192 unknown provider "${u.provider}"`);
-    throw new Error(`[claudish] DEFAULT_ROUTING_RULES references unknown providers:
-${lines.join(`
-`)}`);
-  }
-}
-function validateDefaultRoutingRules() {
-  validateRoutingRulesAgainstProviders(DEFAULT_ROUTING_RULES);
-}
-var DEFAULT_ROUTING_RULES;
-var init_default_routing_rules = __esm(() => {
-  init_model_parser();
-  init_provider_definitions();
-  DEFAULT_ROUTING_RULES = {
-    "claude-*": ["native-anthropic", "openrouter"],
-    "gpt-*": ["openai-codex", "openai", "openrouter"],
-    "o1-*": ["openai-codex", "openai", "openrouter"],
-    "o3-*": ["openai-codex", "openai", "openrouter"],
-    "gemini-*": ["gemini-codeassist", "google", "openrouter"],
-    "grok-*": ["x-ai", "openrouter"],
-    "kimi-*": ["kimi-coding", "kimi", "openrouter"],
-    "k3*": ["kimi-coding", "kimi", "openrouter"],
-    "minimax-*": ["minimax-coding", "minimax", "openrouter"],
-    "glm-*": ["glm-coding", "glm", "openrouter"],
-    "z-ai-*": ["z-ai", "openrouter"],
-    "deepseek-*": ["deepseek", "openrouter"],
-    fugu: ["sakana-subscription", "sakana"],
-    "fugu-*": ["sakana-subscription", "sakana"],
-    "*-zen": ["opencode-zen"],
-    "*": ["openrouter"]
-  };
-  validateDefaultRoutingRules();
-});
-
-// src/providers/routing-rules.ts
-function mergeRoutingRules(defaults, global_, local) {
-  return { ...defaults, ...global_, ...local };
-}
-function loadRoutingRules() {
-  const local = loadLocalConfig()?.routing ?? {};
-  const global_ = loadConfig().routing ?? {};
-  validateRoutingRules(local);
-  validateRoutingRules(global_);
-  return mergeRoutingRules(DEFAULT_ROUTING_RULES, global_, local);
-}
-function validateRoutingRules(rules) {
-  const seenLower = new Map;
-  for (const key of Object.keys(rules)) {
-    if (key !== "*" && (key.match(/\*/g) || []).length > 1) {
-      console.error(`[claudish] Warning: routing pattern "${key}" has multiple wildcards \u2014 only single * is supported. This pattern may not match as expected.`);
-    }
-    const lower = key.toLowerCase();
-    const prior = seenLower.get(lower);
-    if (prior !== undefined && prior !== key) {
-      console.error(`[claudish] Warning: routing patterns "${prior}" and "${key}" collide case-insensitively. Matching is case-insensitive, so one will silently shadow the other. Pick one casing and remove the duplicate.`);
-    } else {
-      seenLower.set(lower, key);
-    }
-  }
-}
-function matchRoutingRule(modelName, rules) {
-  const lowered = modelName.toLowerCase();
-  for (const [key, entries] of Object.entries(rules)) {
-    if (!key.includes("*") && key.toLowerCase() === lowered)
-      return entries;
-  }
-  const globKeys = Object.keys(rules).filter((k) => k !== "*" && k.includes("*")).sort((a, b) => b.length - a.length);
-  for (const pattern of globKeys) {
-    if (globMatch(pattern, modelName))
-      return rules[pattern];
-  }
-  if (rules["*"] !== undefined)
-    return rules["*"];
-  return null;
-}
-function buildRoutingChain(entries, originalModelName, cachePath) {
-  const routes = [];
-  for (const entry of entries) {
-    const atIdx = entry.indexOf("@");
-    let providerRaw;
-    let modelName;
-    if (atIdx !== -1) {
-      providerRaw = entry.slice(0, atIdx);
-      modelName = entry.slice(atIdx + 1);
-    } else {
-      providerRaw = entry;
-      modelName = originalModelName;
-    }
-    const provider = PROVIDER_SHORTCUTS[providerRaw.toLowerCase()] ?? providerRaw.toLowerCase();
-    if (atIdx === -1) {
-      const routing = resolveSubscriptionRouting(modelName, provider, cachePath);
-      if (routing.kind === "not-served")
-        continue;
-      if (routing.kind === "serves")
-        modelName = routing.externalId;
-    }
-    let modelSpec;
-    if (provider === "openrouter") {
-      const resolution = resolveModelNameSync(modelName, "openrouter");
-      modelSpec = resolution.resolvedId;
-    } else {
-      const prefix = PROVIDER_TO_PREFIX[provider] ?? provider;
-      modelSpec = `${prefix}@${modelName}`;
-    }
-    const displayName = DISPLAY_NAMES[provider] ?? provider;
-    routes.push({ provider, modelSpec, displayName });
-  }
-  return routes;
-}
-function globMatch(pattern, value) {
-  const star = pattern.indexOf("*");
-  const p = pattern.toLowerCase();
-  const v = value.toLowerCase();
-  if (star === -1)
-    return p === v;
-  const prefix = p.slice(0, star);
-  const suffix = p.slice(star + 1);
-  return v.startsWith(prefix) && v.endsWith(suffix) && v.length >= prefix.length + suffix.length;
-}
-async function hasCredentialsForProvider(provider) {
-  return credentials.isAvailable(provider);
-}
-async function routeExplicit(modelSpec, model, provider, cachePath) {
-  if (!await hasCredentialsForProvider(provider)) {
-    return {
-      kind: "no-route",
-      reason: `No credentials configured for "${provider}".`,
-      hint: buildCredentialHint(model, [provider]) ?? undefined
-    };
-  }
-  const built = buildRoutingChain([modelSpec], model, cachePath)[0];
-  if (!built) {
-    return {
-      kind: "no-route",
-      reason: `Could not build a route for "${modelSpec}".`
-    };
-  }
-  return { kind: "ok", primary: built, fallbacks: [] };
-}
-async function routeBare(model, nativeProvider, rules, defaultProvider, cachePath) {
-  const matched = matchRoutingRule(model, rules) ?? [];
-  const entries = [...matched];
-  if (defaultProvider && defaultProvider.length > 0) {
-    const canonicalDefault = PROVIDER_SHORTCUTS[defaultProvider.toLowerCase()] ?? defaultProvider.toLowerCase();
-    const alreadyPresent = entries.some((e) => {
-      const atIdx = e.indexOf("@");
-      const providerRaw = atIdx === -1 ? e : e.slice(0, atIdx);
-      const canonical = PROVIDER_SHORTCUTS[providerRaw.toLowerCase()] ?? providerRaw.toLowerCase();
-      return canonical === canonicalDefault;
-    });
-    if (!alreadyPresent)
-      entries.push(defaultProvider);
-  }
-  if (entries.length === 0) {
-    return {
-      kind: "no-route",
-      reason: `No routing rule matched "${model}".`,
-      hint: buildCredentialHint(model, [nativeProvider]) ?? undefined
-    };
-  }
-  const candidates = buildRoutingChain(entries, model, cachePath);
-  const credentialed = [];
-  const skipped = [];
-  const checks4 = await Promise.all(candidates.map((candidate) => hasCredentialsForProvider(candidate.provider)));
-  candidates.forEach((candidate, i) => {
-    if (checks4[i]) {
-      credentialed.push(candidate);
-    } else {
-      skipped.push(candidate.provider);
-    }
-  });
-  if (credentialed.length === 0) {
-    return {
-      kind: "no-route",
-      reason: skipped.length > 0 ? `No credentialed providers in chain for "${model}" (tried: ${skipped.join(", ")}).` : `No providers available for "${model}".`,
-      hint: buildCredentialHint(model, skipped) ?? undefined
-    };
-  }
-  const [primary, ...fallbacks] = credentialed;
-  return { kind: "ok", primary, fallbacks };
-}
-async function route(modelSpec, rulesOverride, defaultProviderOverride, cachePath) {
-  const parsed = parseModelSpec(modelSpec);
-  if (parsed.isExplicitProvider) {
-    return routeExplicit(modelSpec, parsed.model, parsed.provider, cachePath);
-  }
-  const rules = rulesOverride ?? loadRoutingRules();
-  const defaultProvider = defaultProviderOverride !== undefined ? defaultProviderOverride : rulesOverride !== undefined ? undefined : loadConfig().defaultProvider;
-  return routeBare(parsed.model, parsed.provider, rules, defaultProvider, cachePath);
-}
-var init_routing_rules = __esm(() => {
-  init_model_catalog();
-  init_authority();
-  init_profile_config();
-  init_auto_route();
-  init_default_routing_rules();
-  init_model_catalog_resolver();
-  init_model_parser();
-  init_model_parser();
-  init_routing_hints();
-});
-
 // src/handlers/shared/local-queue.ts
 class LocalModelQueue {
   static instance = null;
@@ -43250,10 +43865,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
       };
@@ -43348,7 +43963,7 @@ class LocalModelQueue {
     return parsed;
   }
   delay(ms) {
-    return new Promise((resolve2) => setTimeout(resolve2, ms));
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
   getStats() {
     return {
@@ -43650,10 +44265,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);
@@ -43721,7 +44336,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() {
@@ -43995,6 +44610,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;
@@ -44401,6 +45023,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();
@@ -44443,9 +45067,9 @@ import {
   readdirSync as readdirSync2,
   writeFileSync as writeFileSync11
 } from "fs";
-import { join as join20, resolve as resolve2 } from "path";
+import { join as join20, resolve as resolve3 } from "path";
 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}`);
@@ -44557,7 +45181,7 @@ async function runModels(sessionPath, opts = {}) {
     });
     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 = () => {
@@ -44565,7 +45189,7 @@ async function runModels(sessionPath, opts = {}) {
           return;
         if (statusCache.models[anonId].state === "TIMEOUT") {
           resolved = true;
-          resolve3();
+          resolve4();
           return;
         }
         resolved = true;
@@ -44585,14 +45209,14 @@ async function runModels(sessionPath, opts = {}) {
           } : 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) {
@@ -44610,7 +45234,7 @@ async function runModels(sessionPath, opts = {}) {
   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];
@@ -44624,7 +45248,7 @@ async function runModels(sessionPath, opts = {}) {
             opts.onStatusChange?.(id, statusCache.models[id]);
           }
         }
-        resolve3();
+        resolve4();
       }, timeoutMs);
     })
   ]);
@@ -47671,13 +48295,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 };
     }
   };
 });
@@ -47714,7 +48338,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 }));
@@ -47741,7 +48365,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();
@@ -53582,7 +54206,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) => {
@@ -53592,7 +54216,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"));
       }
@@ -58853,7 +59477,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",
@@ -58871,6 +59495,7 @@ var init_config = __esm(() => {
     ANTHROPIC_DEFAULT_HAIKU_MODEL: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
     CLAUDE_CODE_SUBAGENT_MODEL: "CLAUDE_CODE_SUBAGENT_MODEL",
     CLAUDE_CODE_AUTO_COMPACT_WINDOW: "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
+    CLAUDE_CODE_MAX_CONTEXT_TOKENS: "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
     OLLAMA_BASE_URL: "OLLAMA_BASE_URL",
     OLLAMA_HOST: "OLLAMA_HOST",
     LMSTUDIO_BASE_URL: "LMSTUDIO_BASE_URL",
@@ -59147,62 +59772,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, {
@@ -59734,7 +60303,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,
@@ -62673,8 +63242,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 = () => {
@@ -63285,7 +63854,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>`;
@@ -64343,7 +64912,7 @@ function printAvailableModels() {
 }
 var __filename3, __dirname3;
 var init_cli = __esm(() => {
-  init_config();
+  init_config2();
   init_model_loader();
   init_model_selector();
   init_probe_results_printer();
@@ -64459,7 +65028,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);
@@ -70192,14 +70761,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");
       })
@@ -71645,8 +72214,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));
@@ -71758,6 +72327,7 @@ var init_terminal_isolation = __esm(() => {
 var exports_claude_runner = {};
 __export(exports_claude_runner, {
   runClaudeWithProxy: () => runClaudeWithProxy,
+  resolveContextWindowEnv: () => resolveContextWindowEnv,
   managedSettingsForcesClaudeAi: () => managedSettingsForcesClaudeAi,
   isProxyAuthMode: () => isProxyAuthMode,
   computeMainThreadContextWindow: () => computeMainThreadContextWindow,
@@ -72021,6 +72591,27 @@ async function computeMainThreadContextWindow(config3, cachePath) {
   }
   return Number.isFinite(min) ? min : 0;
 }
+function resolveContextWindowEnv(realWindow, processEnv = process.env) {
+  const vars = {};
+  if (!(realWindow > 0))
+    return { vars };
+  if (!processEnv[ENV.CLAUDE_CODE_MAX_CONTEXT_TOKENS]) {
+    vars[ENV.CLAUDE_CODE_MAX_CONTEXT_TOKENS] = String(realWindow);
+  }
+  if (processEnv[ENV.CLAUDE_CODE_AUTO_COMPACT_WINDOW])
+    return { vars };
+  if (realWindow >= MIN_AUTO_COMPACT_WINDOW) {
+    vars[ENV.CLAUDE_CODE_AUTO_COMPACT_WINDOW] = String(realWindow);
+    return {
+      vars,
+      notice: `[claudish] Auto-compact window: ${realWindow.toLocaleString()} tokens ` + "(Claude Code compacts before the backend's real limit)"
+    };
+  }
+  return {
+    vars,
+    notice: `[claudish] Model's real context window (${realWindow.toLocaleString()}) is below ` + `Claude Code's ${MIN_AUTO_COMPACT_WINDOW.toLocaleString()}-token auto-compact floor \u2014 ` + "leaving CLAUDE_CODE_AUTO_COMPACT_WINDOW unset so native auto-compaction stays on."
+  };
+}
 async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
   const hasProfileMappings = config3.modelOpus || config3.modelSonnet || config3.modelHaiku || config3.modelSubagent;
   const modelId = config3.model || (hasProfileMappings || config3.monitor ? undefined : "unknown");
@@ -72091,16 +72682,11 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     } else {
       env.ANTHROPIC_API_KEY = "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx";
       env.ANTHROPIC_AUTH_TOKEN = "placeholder-token-not-used-proxy-handles-auth";
-      if (!process.env[ENV.CLAUDE_CODE_AUTO_COMPACT_WINDOW]) {
-        const autoCompactWindow = await computeMainThreadContextWindow(config3);
-        if (autoCompactWindow >= MIN_AUTO_COMPACT_WINDOW) {
-          env[ENV.CLAUDE_CODE_AUTO_COMPACT_WINDOW] = String(autoCompactWindow);
-          if (!config3.quiet) {
-            console.error(`[claudish] Auto-compact window: ${autoCompactWindow.toLocaleString()} tokens ` + "(Claude Code compacts before the backend's real limit)");
-          }
-        } else if (autoCompactWindow > 0 && !config3.quiet) {
-          console.error(`[claudish] Model's real context window (${autoCompactWindow.toLocaleString()}) is below ` + `Claude Code's ${MIN_AUTO_COMPACT_WINDOW.toLocaleString()}-token auto-compact floor \u2014 ` + "leaving CLAUDE_CODE_AUTO_COMPACT_WINDOW unset so native auto-compaction stays on.");
-        }
+      const realWindow = await computeMainThreadContextWindow(config3);
+      const contextEnv = resolveContextWindowEnv(realWindow, process.env);
+      Object.assign(env, contextEnv.vars);
+      if (contextEnv.notice && !config3.quiet) {
+        console.error(contextEnv.notice);
       }
     }
   }
@@ -72179,10 +72765,10 @@ Or set CLAUDE_PATH to your custom installation:`);
     });
   }
   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();
@@ -72262,9 +72848,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()) {
@@ -72287,7 +72873,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();
@@ -72654,9 +73240,9 @@ async function subscribeToMagmux(sockPath, onEvent) {
   for (let attempt = 0;attempt < 40; attempt++) {
     if (existsSync24(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;
@@ -72667,7 +73253,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) => {
@@ -72690,7 +73276,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);
@@ -72766,9 +73352,9 @@ 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);
@@ -72797,7 +73383,7 @@ 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 { join as join28, resolve as resolve4 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -72895,7 +73481,7 @@ 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,
+    resolve: resolve4,
     exists: existsSync25
   });
   if (plan.kind === "none")
@@ -73004,7 +73590,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,
@@ -73097,11 +73683,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";