claudish 7.24.0 → 7.25.0

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.24.0";
+var VERSION = "7.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}`);
@@ -36790,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 = [];
@@ -37112,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;
@@ -37831,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";
@@ -38576,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 {
@@ -39306,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({
@@ -39337,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();
@@ -39383,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}`);
               }
@@ -39414,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) {
@@ -39463,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) {
@@ -39482,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);
                   }
@@ -39573,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) {
@@ -39809,6 +40400,7 @@ class ComposedHandler {
   explicitAdapter;
   modelAdapter;
   middlewareManager;
+  behaviorEngine;
   tokenTracker;
   targetModel;
   bareModelName;
@@ -39835,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,
@@ -39947,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) {
@@ -39993,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";
@@ -40280,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;
@@ -40299,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();
@@ -40328,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";
@@ -40365,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, {
@@ -40461,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();
@@ -41258,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(() => {
@@ -41541,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;
@@ -41722,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`);
     }
@@ -41840,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)
@@ -42272,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"));
 }
@@ -42292,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
   });
@@ -42350,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"));
@@ -42407,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);
@@ -42466,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) {
@@ -43264,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
       };
@@ -43362,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 {
@@ -43664,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);
@@ -43735,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() {
@@ -44009,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;
@@ -44415,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();
@@ -44457,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}`);
@@ -44571,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 = () => {
@@ -44579,7 +45189,7 @@ async function runModels(sessionPath, opts = {}) {
           return;
         if (statusCache.models[anonId].state === "TIMEOUT") {
           resolved = true;
-          resolve3();
+          resolve4();
           return;
         }
         resolved = true;
@@ -44599,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) {
@@ -44624,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];
@@ -44638,7 +45248,7 @@ async function runModels(sessionPath, opts = {}) {
             opts.onStatusChange?.(id, statusCache.models[id]);
           }
         }
-        resolve3();
+        resolve4();
       }, timeoutMs);
     })
   ]);
@@ -47685,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 };
     }
   };
 });
@@ -47728,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 }));
@@ -47755,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();
@@ -53596,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) => {
@@ -53606,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"));
       }
@@ -58867,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",
@@ -59162,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, {
@@ -59749,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,
@@ -62688,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 = () => {
@@ -63300,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>`;
@@ -64358,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();
@@ -64474,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);
@@ -70207,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");
       })
@@ -71660,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));
@@ -72211,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();
@@ -72294,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()) {
@@ -72319,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();
@@ -72686,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;
@@ -72699,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) => {
@@ -72722,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);
@@ -72798,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);
@@ -72829,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);
@@ -72927,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")
@@ -73036,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,
@@ -73129,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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "7.24.0",
+  "version": "7.25.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,10 +60,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "7.24.0",
-    "@claudish/magmux-darwin-x64": "7.24.0",
-    "@claudish/magmux-linux-arm64": "7.24.0",
-    "@claudish/magmux-linux-x64": "7.24.0"
+    "@claudish/magmux-darwin-arm64": "7.25.0",
+    "@claudish/magmux-darwin-x64": "7.25.0",
+    "@claudish/magmux-linux-arm64": "7.25.0",
+    "@claudish/magmux-linux-x64": "7.25.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",