claudish 3.3.10 → 3.4.0

package/dist/index.js

@@ -56301,31 +56301,51 @@ var init_remote_provider_types = __esm(() => {
     "gemini-3.0-flash": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
     "gemini-2.0-flash": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
     "gemini-2.0-flash-thinking": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
-    default: { inputCostPer1M: 0.5, outputCostPer1M: 2 }
+    default: { inputCostPer1M: 0.5, outputCostPer1M: 2, isEstimate: true }
   };
   OPENAI_PRICING = {
-    "gpt-5": { inputCostPer1M: 2, outputCostPer1M: 8 },
-    "gpt-5.2": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
-    "gpt-5-turbo": { inputCostPer1M: 1.5, outputCostPer1M: 6 },
-    "gpt-5.1-codex": { inputCostPer1M: 3, outputCostPer1M: 12 },
+    "gpt-5.2": { inputCostPer1M: 1.75, outputCostPer1M: 14 },
+    "gpt-5.2-codex": { inputCostPer1M: 1.75, outputCostPer1M: 14 },
+    "gpt-5.2-chat-latest": { inputCostPer1M: 1.75, outputCostPer1M: 14 },
+    "gpt-5.2-pro": { inputCostPer1M: 21, outputCostPer1M: 168 },
+    "gpt-5.1": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5.1-codex": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5.1-codex-max": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5.1-codex-mini": { inputCostPer1M: 0.25, outputCostPer1M: 2 },
+    "gpt-5.1-chat-latest": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5-codex": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5-chat-latest": { inputCostPer1M: 1.25, outputCostPer1M: 10 },
+    "gpt-5-mini": { inputCostPer1M: 0.25, outputCostPer1M: 2 },
+    "gpt-5-nano": { inputCostPer1M: 0.05, outputCostPer1M: 0.4 },
+    "gpt-5-pro": { inputCostPer1M: 15, outputCostPer1M: 120 },
+    "gpt-4.1": { inputCostPer1M: 2, outputCostPer1M: 8 },
+    "gpt-4.1-mini": { inputCostPer1M: 0.4, outputCostPer1M: 1.6 },
+    "gpt-4.1-nano": { inputCostPer1M: 0.1, outputCostPer1M: 0.4 },
     "gpt-4o": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
+    "gpt-4o-2024-05-13": { inputCostPer1M: 5, outputCostPer1M: 15 },
     "gpt-4o-mini": { inputCostPer1M: 0.15, outputCostPer1M: 0.6 },
     "gpt-4o-audio": { inputCostPer1M: 2.5, outputCostPer1M: 10 },
     o1: { inputCostPer1M: 15, outputCostPer1M: 60 },
-    "o1-mini": { inputCostPer1M: 3, outputCostPer1M: 12 },
-    "o1-preview": { inputCostPer1M: 15, outputCostPer1M: 60 },
-    o3: { inputCostPer1M: 15, outputCostPer1M: 60 },
-    "o3-mini": { inputCostPer1M: 3, outputCostPer1M: 12 },
+    "o1-mini": { inputCostPer1M: 1.1, outputCostPer1M: 4.4 },
+    "o1-pro": { inputCostPer1M: 150, outputCostPer1M: 600 },
+    o3: { inputCostPer1M: 2, outputCostPer1M: 8 },
+    "o3-mini": { inputCostPer1M: 1.1, outputCostPer1M: 4.4 },
+    "o3-pro": { inputCostPer1M: 20, outputCostPer1M: 80 },
+    "o3-deep-research": { inputCostPer1M: 10, outputCostPer1M: 40 },
+    "o4-mini": { inputCostPer1M: 1.1, outputCostPer1M: 4.4 },
+    "o4-mini-deep-research": { inputCostPer1M: 2, outputCostPer1M: 8 },
     "gpt-4-turbo": { inputCostPer1M: 10, outputCostPer1M: 30 },
     "gpt-4-turbo-preview": { inputCostPer1M: 10, outputCostPer1M: 30 },
     "gpt-4": { inputCostPer1M: 30, outputCostPer1M: 60 },
     "gpt-3.5-turbo": { inputCostPer1M: 0.5, outputCostPer1M: 1.5 },
-    default: { inputCostPer1M: 2, outputCostPer1M: 8 }
+    "codex-mini-latest": { inputCostPer1M: 1.5, outputCostPer1M: 6 },
+    default: { inputCostPer1M: 2, outputCostPer1M: 8, isEstimate: true }
   };
   MINIMAX_PRICING = {
     "minimax-m2.1": { inputCostPer1M: 0.12, outputCostPer1M: 0.48 },
     "minimax-m2": { inputCostPer1M: 0.12, outputCostPer1M: 0.48 },
-    default: { inputCostPer1M: 0.12, outputCostPer1M: 0.48 }
+    default: { inputCostPer1M: 0.12, outputCostPer1M: 0.48, isEstimate: true }
   };
   KIMI_PRICING = {
     "kimi-k2-thinking-turbo": { inputCostPer1M: 0.32, outputCostPer1M: 0.48 },
@@ -56333,13 +56353,13 @@ var init_remote_provider_types = __esm(() => {
     "kimi-k2-turbo-preview": { inputCostPer1M: 0.2, outputCostPer1M: 0.4 },
     "kimi-k2-0905-preview": { inputCostPer1M: 0.2, outputCostPer1M: 0.4 },
     "kimi-k2": { inputCostPer1M: 0.2, outputCostPer1M: 0.4 },
-    default: { inputCostPer1M: 0.32, outputCostPer1M: 0.48 }
+    default: { inputCostPer1M: 0.32, outputCostPer1M: 0.48, isEstimate: true }
   };
   GLM_PRICING = {
     "glm-4.7": { inputCostPer1M: 0.16, outputCostPer1M: 0.8 },
     "glm-4": { inputCostPer1M: 0.16, outputCostPer1M: 0.8 },
     "glm-4-plus": { inputCostPer1M: 0.5, outputCostPer1M: 2 },
-    default: { inputCostPer1M: 0.16, outputCostPer1M: 0.8 }
+    default: { inputCostPer1M: 0.16, outputCostPer1M: 0.8, isEstimate: true }
   };
 });
 
@@ -56980,7 +57000,7 @@ class OpenAIHandler {
     }
     return `${this.provider.baseUrl}${this.provider.apiPath}`;
   }
-  writeTokenFile(input, output) {
+  writeTokenFile(input, output, isEstimate) {
     try {
       const total = input + output;
       const leftPct = this.contextWindow > 0 ? Math.max(0, Math.min(100, Math.round((this.contextWindow - total) / this.contextWindow * 100))) : 100;
@@ -56993,6 +57013,9 @@ class OpenAIHandler {
         context_left_percent: leftPct,
         updated_at: Date.now()
       };
+      if (isEstimate) {
+        data.cost_is_estimate = true;
+      }
       const claudishDir = join9(homedir5(), ".claudish");
       mkdirSync6(claudishDir, { recursive: true });
       writeFileSync8(join9(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
@@ -57001,13 +57024,23 @@ class OpenAIHandler {
     }
   }
   updateTokenTracking(inputTokens, outputTokens) {
-    const incrementalInputTokens = Math.max(0, inputTokens - this.sessionInputTokens);
-    this.sessionInputTokens = inputTokens;
+    let incrementalInputTokens;
+    if (inputTokens >= this.sessionInputTokens) {
+      incrementalInputTokens = inputTokens - this.sessionInputTokens;
+      this.sessionInputTokens = inputTokens;
+    } else if (inputTokens < this.sessionInputTokens * 0.5) {
+      incrementalInputTokens = inputTokens;
+      log(`[OpenAIHandler] Token tracking: detected concurrent conversation (${inputTokens} < ${this.sessionInputTokens}), charging full input`);
+    } else {
+      incrementalInputTokens = inputTokens;
+      this.sessionInputTokens = inputTokens;
+      log(`[OpenAIHandler] Token tracking: ambiguous token decrease (${inputTokens} vs ${this.sessionInputTokens}), charging full input`);
+    }
     this.sessionOutputTokens += outputTokens;
     const pricing = this.getPricing();
     const cost = incrementalInputTokens / 1e6 * pricing.inputCostPer1M + outputTokens / 1e6 * pricing.outputCostPer1M;
     this.sessionTotalCost += cost;
-    this.writeTokenFile(inputTokens, this.sessionOutputTokens);
+    this.writeTokenFile(Math.max(inputTokens, this.sessionInputTokens), this.sessionOutputTokens, pricing.isEstimate);
   }
   convertMessages(claudeRequest) {
     return convertMessagesToOpenAI(claudeRequest, `openai/${this.modelName}`, filterIdentity);
@@ -57158,7 +57191,7 @@ class OpenAIHandler {
       payload.instructions = claudeRequest.system;
     }
     if (claudeRequest.max_tokens) {
-      payload.max_output_tokens = claudeRequest.max_tokens;
+      payload.max_output_tokens = Math.max(16, claudeRequest.max_tokens);
     }
     if (tools.length > 0) {
       payload.tools = tools.map((tool) => {
@@ -57188,11 +57221,22 @@ class OpenAIHandler {
     let outputTokens = 0;
     let hasTextContent = false;
     let hasToolUse = false;
+    let lastActivity = Date.now();
+    let pingInterval = null;
+    let isClosed = false;
     const functionCalls = new Map;
     const stream = new ReadableStream({
       start: async (controller) => {
+        const send = (event, data) => {
+          if (!isClosed) {
+            controller.enqueue(encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`));
+          }
+        };
         log(`[OpenAIHandler] Sending message_start with placeholder tokens`);
-        const messageStart = {
+        send("message_start", {
           type: "message_start",
           message: {
             id: `msg_${Date.now()}`,
@@ -57204,20 +57248,19 @@ class OpenAIHandler {
             stop_sequence: null,
             usage: { input_tokens: 100, output_tokens: 1 }
           }
-        };
-        controller.enqueue(encoder.encode(`event: message_start
-data: ${JSON.stringify(messageStart)}
-
-`));
-        controller.enqueue(encoder.encode(`event: ping
-data: {"type":"ping"}
-
-`));
+        });
+        send("ping", { type: "ping" });
+        pingInterval = setInterval(() => {
+          if (!isClosed && Date.now() - lastActivity > 1000) {
+            send("ping", { type: "ping" });
+          }
+        }, 1000);
         try {
           while (true) {
             const { done, value } = await reader.read();
             if (done)
               break;
+            lastActivity = Date.now();
             buffer += decoder.decode(value, { stream: true });
             const lines = buffer.split(`
 `);
@@ -57241,86 +57284,99 @@ data: {"type":"ping"}
                 }
                 if (event.type === "response.output_text.delta") {
                   if (!hasTextContent) {
-                    const blockStart = {
+                    send("content_block_start", {
                       type: "content_block_start",
                       index: blockIndex,
                       content_block: { type: "text", text: "" }
-                    };
-                    controller.enqueue(encoder.encode(`event: content_block_start
-data: ${JSON.stringify(blockStart)}
-
-`));
+                    });
                     hasTextContent = true;
                   }
-                  const delta = {
+                  send("content_block_delta", {
                     type: "content_block_delta",
                     index: blockIndex,
                     delta: { type: "text_delta", text: event.delta || "" }
-                  };
-                  controller.enqueue(encoder.encode(`event: content_block_delta
-data: ${JSON.stringify(delta)}
-
-`));
+                  });
                 } else if (event.type === "response.output_item.added") {
+                  if (getLogLevel() === "debug" && event.item?.type) {
+                    log(`[OpenAIHandler] Output item added: type=${event.item.type}, id=${event.item.id || event.item.call_id || "unknown"}`);
+                  }
                   if (event.item?.type === "function_call") {
-                    const callId = event.item.call_id || event.item.id;
+                    const itemId = event.item.id;
+                    const openaiCallId = event.item.call_id || itemId;
+                    const callId = openaiCallId.startsWith("toolu_") ? openaiCallId : `toolu_${openaiCallId.replace(/^fc_/, "")}`;
+                    const fnName = event.item.name || "";
                     const fnIndex = blockIndex + functionCalls.size + (hasTextContent ? 1 : 0);
-                    functionCalls.set(callId, {
-                      name: event.item.name || "",
+                    log(`[OpenAIHandler] Function call: itemId=${itemId}, openaiCallId=${openaiCallId}, claudeId=${callId}, name=${fnName}, index=${fnIndex}`);
+                    const fnCallData = {
+                      name: fnName,
                       arguments: "",
-                      index: fnIndex
-                    });
+                      index: fnIndex,
+                      claudeId: callId
+                    };
+                    functionCalls.set(openaiCallId, fnCallData);
+                    if (itemId && itemId !== openaiCallId) {
+                      functionCalls.set(itemId, fnCallData);
+                    }
                     if (hasTextContent && !hasToolUse) {
-                      const blockStop = { type: "content_block_stop", index: blockIndex };
-                      controller.enqueue(encoder.encode(`event: content_block_stop
-data: ${JSON.stringify(blockStop)}
-
-`));
+                      send("content_block_stop", { type: "content_block_stop", index: blockIndex });
                       blockIndex++;
                     }
-                    const toolStart = {
+                    send("content_block_start", {
                       type: "content_block_start",
                       index: fnIndex,
                       content_block: {
                         type: "tool_use",
                         id: callId,
-                        name: event.item.name || "",
+                        name: fnName,
                         input: {}
                       }
-                    };
-                    controller.enqueue(encoder.encode(`event: content_block_start
-data: ${JSON.stringify(toolStart)}
-
-`));
+                    });
                     hasToolUse = true;
+                  } else if (event.item?.type === "reasoning") {
+                    log(`[OpenAIHandler] Reasoning block started`);
+                  }
+                } else if (event.type === "response.reasoning_summary_text.delta") {
+                  if (!hasTextContent) {
+                    send("content_block_start", {
+                      type: "content_block_start",
+                      index: blockIndex,
+                      content_block: { type: "text", text: "" }
+                    });
+                    hasTextContent = true;
                   }
+                  send("content_block_delta", {
+                    type: "content_block_delta",
+                    index: blockIndex,
+                    delta: { type: "text_delta", text: event.delta || "" }
+                  });
                 } else if (event.type === "response.function_call_arguments.delta") {
                   const callId = event.call_id || event.item_id;
+                  if (getLogLevel() === "debug" && !functionCalls.has(callId)) {
+                    log(`[OpenAIHandler] Argument delta lookup failed: callId=${callId}, stored keys=[${Array.from(functionCalls.keys()).join(", ")}]`);
+                  }
                   const fnCall = functionCalls.get(callId);
                   if (fnCall) {
                     fnCall.arguments += event.delta || "";
-                    const delta = {
+                    send("content_block_delta", {
                       type: "content_block_delta",
                       index: fnCall.index,
                       delta: { type: "input_json_delta", partial_json: event.delta || "" }
-                    };
-                    controller.enqueue(encoder.encode(`event: content_block_delta
-data: ${JSON.stringify(delta)}
-
-`));
+                    });
                   }
                 } else if (event.type === "response.output_item.done") {
                   if (event.item?.type === "function_call") {
                     const callId = event.item.call_id || event.item.id;
-                    const fnCall = functionCalls.get(callId);
+                    const fnCall = functionCalls.get(callId) || functionCalls.get(event.item.id);
                     if (fnCall) {
-                      const blockStop = { type: "content_block_stop", index: fnCall.index };
-                      controller.enqueue(encoder.encode(`event: content_block_stop
-data: ${JSON.stringify(blockStop)}
-
-`));
+                      send("content_block_stop", { type: "content_block_stop", index: fnCall.index });
                     }
                   }
+                } else if (event.type === "response.incomplete") {
+                  log(`[OpenAIHandler] Response incomplete: ${event.reason || "unknown reason"}`);
+                  if (event.response?.usage) {
+                    inputTokens = event.response.usage.input_tokens || inputTokens;
+                    outputTokens = event.response.usage.output_tokens || outputTokens;
+                  }
                 } else if (event.type === "response.completed" || event.type === "response.done") {
                   if (event.response?.usage) {
                     inputTokens = event.response.usage.input_tokens || 0;
@@ -57337,31 +57393,29 @@ data: ${JSON.stringify(blockStop)}
               }
             }
           }
-          if (hasTextContent && !hasToolUse) {
-            const blockStop = { type: "content_block_stop", index: blockIndex };
-            controller.enqueue(encoder.encode(`event: content_block_stop
-data: ${JSON.stringify(blockStop)}
-
-`));
+          if (pingInterval) {
+            clearInterval(pingInterval);
+            pingInterval = null;
+          }
+          if (hasTextContent) {
+            send("content_block_stop", { type: "content_block_stop", index: blockIndex });
           }
           const stopReason = hasToolUse ? "tool_use" : "end_turn";
-          const messageDelta = {
+          send("message_delta", {
             type: "message_delta",
             delta: { stop_reason: stopReason, stop_sequence: null },
             usage: { input_tokens: inputTokens, output_tokens: outputTokens }
-          };
-          controller.enqueue(encoder.encode(`event: message_delta
-data: ${JSON.stringify(messageDelta)}
-
-`));
-          const messageStop = { type: "message_stop" };
-          controller.enqueue(encoder.encode(`event: message_stop
-data: ${JSON.stringify(messageStop)}
-
-`));
+          });
+          send("message_stop", { type: "message_stop" });
+          isClosed = true;
           this.updateTokenTracking(inputTokens, outputTokens);
           controller.close();
         } catch (error46) {
+          if (pingInterval) {
+            clearInterval(pingInterval);
+            pingInterval = null;
+          }
+          isClosed = true;
           log(`[OpenAIHandler] Responses streaming error: ${error46}`);
           controller.error(error46);
         }
@@ -58122,310 +58176,96 @@ var init_dist11 = __esm(() => {
   init_config();
 });
 
-// src/claude-runner.ts
-var exports_claude_runner = {};
-__export(exports_claude_runner, {
-  runClaudeWithProxy: () => runClaudeWithProxy,
-  checkClaudeInstalled: () => checkClaudeInstalled
-});
-import { spawn } from "node:child_process";
-import { writeFileSync as writeFileSync10, unlinkSync, mkdirSync as mkdirSync8 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join11 } from "node:path";
-function isWindows() {
-  return process.platform === "win32";
-}
-function createStatusLineScript(tokenFilePath) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir();
-  const claudishDir = join11(homeDir, ".claudish");
-  const timestamp = Date.now();
-  const scriptPath = join11(claudishDir, `status-${timestamp}.js`);
-  const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
-  const script = `
-const fs = require('fs');
-const path = require('path');
-
-const CYAN = "\\x1b[96m";
-const YELLOW = "\\x1b[93m";
-const GREEN = "\\x1b[92m";
-const MAGENTA = "\\x1b[95m";
-const DIM = "\\x1b[2m";
-const RESET = "\\x1b[0m";
-const BOLD = "\\x1b[1m";
-
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => input += chunk);
-process.stdin.on('end', () => {
-  try {
-    let dir = path.basename(process.cwd());
-    if (dir.length > 15) dir = dir.substring(0, 12) + '...';
-
-    let ctx = 100, cost = 0;
-    const model = process.env.CLAUDISH_ACTIVE_MODEL_NAME || 'unknown';
-    const isLocal = process.env.CLAUDISH_IS_LOCAL === 'true';
-
+// src/model-loader.ts
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "node:fs";
+import { join as join11, dirname as dirname4 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+function loadModelInfo2() {
+  if (_cachedModelInfo2) {
+    return _cachedModelInfo2;
+  }
+  const jsonPath = join11(__dirname5, "../recommended-models.json");
+  if (existsSync6(jsonPath)) {
     try {
-      const tokens = JSON.parse(fs.readFileSync('${escapedTokenPath}', 'utf-8'));
-      cost = tokens.total_cost || 0;
-      ctx = tokens.context_left_percent || 100;
-    } catch (e) {
-      try {
-        const json = JSON.parse(input);
-        cost = json.total_cost_usd || 0;
-      } catch {}
+      const jsonContent = readFileSync5(jsonPath, "utf-8");
+      const data = JSON.parse(jsonContent);
+      const modelInfo = {};
+      for (const model of data.models) {
+        modelInfo[model.id] = {
+          name: model.name,
+          description: model.description,
+          priority: model.priority,
+          provider: model.provider
+        };
+      }
+      modelInfo.custom = {
+        name: "Custom Model",
+        description: "Enter any OpenRouter model ID manually",
+        priority: 999,
+        provider: "Custom"
+      };
+      _cachedModelInfo2 = modelInfo;
+      return modelInfo;
+    } catch (error46) {
+      console.error("❌ Failed to load recommended-models.json:", error46);
+      throw new Error("Cannot load model information");
     }
-
-    const costDisplay = isLocal ? 'LOCAL' : ('$' + cost.toFixed(3));
-    console.log(\`\${CYAN}\${BOLD}\${dir}\${RESET} \${DIM}•\${RESET} \${YELLOW}\${model}\${RESET} \${DIM}•\${RESET} \${GREEN}\${costDisplay}\${RESET} \${DIM}•\${RESET} \${MAGENTA}\${ctx}%\${RESET}\`);
-  } catch (e) {
-    console.log('claudish');
   }
-});
-`;
-  writeFileSync10(scriptPath, script, "utf-8");
-  return scriptPath;
+  throw new Error("recommended-models.json not found");
 }
-function createTempSettingsFile(modelDisplay, port) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir();
-  const claudishDir = join11(homeDir, ".claudish");
-  try {
-    mkdirSync8(claudishDir, { recursive: true });
-  } catch {}
-  const timestamp = Date.now();
-  const tempPath = join11(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join11(claudishDir, `tokens-${port}.json`);
-  let statusCommand;
-  if (isWindows()) {
-    const scriptPath = createStatusLineScript(tokenFilePath);
-    statusCommand = `node "${scriptPath}"`;
-  } else {
-    const CYAN2 = "\\033[96m";
-    const YELLOW2 = "\\033[93m";
-    const GREEN2 = "\\033[92m";
-    const MAGENTA = "\\033[95m";
-    const DIM2 = "\\033[2m";
-    const RESET2 = "\\033[0m";
-    const BOLD2 = "\\033[1m";
-    statusCommand = `JSON=$(cat) && DIR=$(basename "$(pwd)") && [ \${#DIR} -gt 15 ] && DIR="\${DIR:0:12}..." || true && CTX=100 && COST="0" && if [ -f "${tokenFilePath}" ]; then TOKENS=$(cat "${tokenFilePath}" 2>/dev/null) && REAL_CTX=$(echo "$TOKENS" | grep -o '"context_left_percent":[0-9]*' | grep -o '[0-9]*') && if [ ! -z "$REAL_CTX" ]; then CTX="$REAL_CTX"; fi; fi && COST=$(echo "$JSON" | grep -o '"total_cost_usd":[0-9.]*' | cut -d: -f2) && [ -z "$COST" ] && COST="0" || true && if [ "$CLAUDISH_IS_LOCAL" = "true" ]; then COST_DISPLAY="LOCAL"; else COST_DISPLAY=$(printf "\\$%.3f" "$COST"); fi && printf "${CYAN2}${BOLD2}%s${RESET2} ${DIM2}•${RESET2} ${YELLOW2}%s${RESET2} ${DIM2}•${RESET2} ${GREEN2}%s${RESET2} ${DIM2}•${RESET2} ${MAGENTA}%s%%${RESET2}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST_DISPLAY" "$CTX"`;
+function getAvailableModels() {
+  if (_cachedModelIds) {
+    return _cachedModelIds;
   }
-  const settings = {
-    statusLine: {
-      type: "command",
-      command: statusCommand,
-      padding: 0
+  const jsonPath = join11(__dirname5, "../recommended-models.json");
+  if (existsSync6(jsonPath)) {
+    try {
+      const jsonContent = readFileSync5(jsonPath, "utf-8");
+      const data = JSON.parse(jsonContent);
+      const modelIds = data.models.sort((a, b) => a.priority - b.priority).map((m) => m.id);
+      const result = [...modelIds, "custom"];
+      _cachedModelIds = result;
+      return result;
+    } catch (error46) {
+      console.error("❌ Failed to load model list from JSON:", error46);
+      throw new Error("Cannot load model list");
     }
-  };
-  writeFileSync10(tempPath, JSON.stringify(settings, null, 2), "utf-8");
-  return tempPath;
+  }
+  throw new Error("recommended-models.json not found");
 }
-async function runClaudeWithProxy(config3, proxyUrl) {
-  const modelId = config3.model || "unknown";
-  const portMatch = proxyUrl.match(/:(\d+)/);
-  const port = portMatch ? portMatch[1] : "unknown";
-  const tempSettingsPath = createTempSettingsFile(modelId, port);
-  const claudeArgs = [];
-  claudeArgs.push("--settings", tempSettingsPath);
-  if (config3.interactive) {
-    if (config3.autoApprove) {
-      claudeArgs.push("--dangerously-skip-permissions");
-    }
-    if (config3.dangerous) {
-      claudeArgs.push("--dangerouslyDisableSandbox");
-    }
-  } else {
-    claudeArgs.push("-p");
-    if (config3.autoApprove) {
-      claudeArgs.push("--dangerously-skip-permissions");
-    }
-    if (config3.dangerous) {
-      claudeArgs.push("--dangerouslyDisableSandbox");
-    }
-    if (config3.jsonOutput) {
-      claudeArgs.push("--output-format", "json");
-    }
-    if (config3.agent && config3.claudeArgs.length > 0) {
-      const modifiedArgs = [...config3.claudeArgs];
-      const agentId = config3.agent.startsWith("@agent-") ? config3.agent : `@agent-${config3.agent}`;
-      modifiedArgs[0] = `Use the ${agentId} agent to: ${modifiedArgs[0]}`;
-      claudeArgs.push(...modifiedArgs);
+var __filename5, __dirname5, _cachedModelInfo2 = null, _cachedModelIds = null;
+var init_model_loader2 = __esm(() => {
+  __filename5 = fileURLToPath4(import.meta.url);
+  __dirname5 = dirname4(__filename5);
+});
+
+// src/utils.ts
+function fuzzyScore2(text, query) {
+  if (!text || !query)
+    return 0;
+  const t = text.toLowerCase();
+  const q = query.toLowerCase();
+  if (t === q)
+    return 1;
+  if (t.startsWith(q))
+    return 0.9;
+  if (t.includes(` ${q}`) || t.includes(`-${q}`) || t.includes(`/${q}`))
+    return 0.8;
+  if (t.includes(q))
+    return 0.6;
+  let score = 0;
+  let tIdx = 0;
+  let qIdx = 0;
+  let consecutive = 0;
+  while (tIdx < t.length && qIdx < q.length) {
+    if (t[tIdx] === q[qIdx]) {
+      score += 1 + consecutive * 0.5;
+      consecutive++;
+      qIdx++;
     } else {
-      claudeArgs.push(...config3.claudeArgs);
+      consecutive = 0;
     }
-  }
-  const isLocalModel = modelId.startsWith("ollama/") || modelId.startsWith("ollama:") || modelId.startsWith("lmstudio/") || modelId.startsWith("lmstudio:") || modelId.startsWith("vllm/") || modelId.startsWith("vllm:") || modelId.startsWith("mlx/") || modelId.startsWith("mlx:") || modelId.startsWith("http://") || modelId.startsWith("https://");
-  const env = {
-    ...process.env,
-    ANTHROPIC_BASE_URL: proxyUrl,
-    [ENV.CLAUDISH_ACTIVE_MODEL_NAME]: modelId,
-    CLAUDISH_IS_LOCAL: isLocalModel ? "true" : "false",
-    [ENV.ANTHROPIC_MODEL]: modelId,
-    [ENV.ANTHROPIC_SMALL_FAST_MODEL]: modelId
-  };
-  if (config3.monitor) {
-    delete env.ANTHROPIC_API_KEY;
-  } else {
-    env.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx";
-  }
-  const log2 = (message) => {
-    if (!config3.quiet) {
-      console.log(message);
-    }
-  };
-  if (config3.interactive) {
-    log2(`
-[claudish] Model: ${modelId}
-`);
-  } else {
-    log2(`
-[claudish] Model: ${modelId}`);
-    log2(`[claudish] Arguments: ${claudeArgs.join(" ")}
-`);
-  }
-  const proc = spawn("claude", claudeArgs, {
-    env,
-    stdio: "inherit",
-    shell: isWindows()
-  });
-  setupSignalHandlers(proc, tempSettingsPath, config3.quiet);
-  const exitCode = await new Promise((resolve) => {
-    proc.on("exit", (code) => {
-      resolve(code ?? 1);
-    });
-  });
-  try {
-    unlinkSync(tempSettingsPath);
-  } catch (error46) {}
-  return exitCode;
-}
-function setupSignalHandlers(proc, tempSettingsPath, quiet) {
-  const signals2 = isWindows() ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
-  for (const signal of signals2) {
-    process.on(signal, () => {
-      if (!quiet) {
-        console.log(`
-[claudish] Received ${signal}, shutting down...`);
-      }
-      proc.kill();
-      try {
-        unlinkSync(tempSettingsPath);
-      } catch {}
-      process.exit(0);
-    });
-  }
-}
-async function checkClaudeInstalled() {
-  try {
-    const isWindows2 = process.platform === "win32";
-    const command = isWindows2 ? "where" : "which";
-    const proc = spawn(command, ["claude"], {
-      stdio: "ignore",
-      shell: isWindows2
-    });
-    const exitCode = await new Promise((resolve) => {
-      proc.on("exit", (code) => {
-        resolve(code ?? 1);
-      });
-    });
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-var init_claude_runner = __esm(() => {
-  init_dist11();
-});
-
-// src/model-loader.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "node:fs";
-import { join as join12, dirname as dirname4 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
-function loadModelInfo2() {
-  if (_cachedModelInfo2) {
-    return _cachedModelInfo2;
-  }
-  const jsonPath = join12(__dirname5, "../recommended-models.json");
-  if (existsSync6(jsonPath)) {
-    try {
-      const jsonContent = readFileSync5(jsonPath, "utf-8");
-      const data = JSON.parse(jsonContent);
-      const modelInfo = {};
-      for (const model of data.models) {
-        modelInfo[model.id] = {
-          name: model.name,
-          description: model.description,
-          priority: model.priority,
-          provider: model.provider
-        };
-      }
-      modelInfo.custom = {
-        name: "Custom Model",
-        description: "Enter any OpenRouter model ID manually",
-        priority: 999,
-        provider: "Custom"
-      };
-      _cachedModelInfo2 = modelInfo;
-      return modelInfo;
-    } catch (error46) {
-      console.error("❌ Failed to load recommended-models.json:", error46);
-      throw new Error("Cannot load model information");
-    }
-  }
-  throw new Error("recommended-models.json not found");
-}
-function getAvailableModels() {
-  if (_cachedModelIds) {
-    return _cachedModelIds;
-  }
-  const jsonPath = join12(__dirname5, "../recommended-models.json");
-  if (existsSync6(jsonPath)) {
-    try {
-      const jsonContent = readFileSync5(jsonPath, "utf-8");
-      const data = JSON.parse(jsonContent);
-      const modelIds = data.models.sort((a, b) => a.priority - b.priority).map((m) => m.id);
-      const result = [...modelIds, "custom"];
-      _cachedModelIds = result;
-      return result;
-    } catch (error46) {
-      console.error("❌ Failed to load model list from JSON:", error46);
-      throw new Error("Cannot load model list");
-    }
-  }
-  throw new Error("recommended-models.json not found");
-}
-var __filename5, __dirname5, _cachedModelInfo2 = null, _cachedModelIds = null;
-var init_model_loader2 = __esm(() => {
-  __filename5 = fileURLToPath4(import.meta.url);
-  __dirname5 = dirname4(__filename5);
-});
-
-// src/utils.ts
-function fuzzyScore2(text, query) {
-  if (!text || !query)
-    return 0;
-  const t = text.toLowerCase();
-  const q = query.toLowerCase();
-  if (t === q)
-    return 1;
-  if (t.startsWith(q))
-    return 0.9;
-  if (t.includes(` ${q}`) || t.includes(`-${q}`) || t.includes(`/${q}`))
-    return 0.8;
-  if (t.includes(q))
-    return 0.6;
-  let score = 0;
-  let tIdx = 0;
-  let qIdx = 0;
-  let consecutive = 0;
-  while (tIdx < t.length && qIdx < q.length) {
-    if (t[tIdx] === q[qIdx]) {
-      score += 1 + consecutive * 0.5;
-      consecutive++;
-      qIdx++;
-    } else {
-      consecutive = 0;
-    }
-    tIdx++;
+    tIdx++;
   }
   if (qIdx === q.length) {
     const compactness = q.length / (tIdx + 1);
@@ -58440,9 +58280,9 @@ __export(exports_cli, {
   parseArgs: () => parseArgs,
   getVersion: () => getVersion
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync11, existsSync as existsSync7, mkdirSync as mkdirSync9, copyFileSync } from "node:fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync10, existsSync as existsSync7, mkdirSync as mkdirSync8, copyFileSync } from "node:fs";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { dirname as dirname5, join as join13 } from "node:path";
+import { dirname as dirname5, join as join12 } from "node:path";
 function getVersion() {
   return VERSION;
 }
@@ -58734,7 +58574,7 @@ async function searchAndPrintModels(query, forceUpdate) {
         throw new Error(`API returned ${response.status}`);
       const data = await response.json();
       models = data.data;
-      writeFileSync11(ALL_MODELS_JSON_PATH2, JSON.stringify({
+      writeFileSync10(ALL_MODELS_JSON_PATH2, JSON.stringify({
         lastUpdated: new Date().toISOString(),
         models
       }), "utf-8");
@@ -58835,7 +58675,7 @@ async function printAllModels(jsonOutput, forceUpdate) {
         throw new Error(`API returned ${response.status}`);
       const data = await response.json();
       models = data.data;
-      writeFileSync11(ALL_MODELS_JSON_PATH2, JSON.stringify({
+      writeFileSync10(ALL_MODELS_JSON_PATH2, JSON.stringify({
         lastUpdated: new Date().toISOString(),
         models
       }), "utf-8");
@@ -59056,7 +58896,7 @@ async function updateModelsFromOpenRouter() {
       source: "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
       models: recommendations
     };
-    writeFileSync11(MODELS_JSON_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
+    writeFileSync10(MODELS_JSON_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
     console.error(`✅ Updated ${recommendations.length} models (last updated: ${updatedData.lastUpdated})`);
   } catch (error46) {
     console.error(`❌ Failed to update models: ${error46 instanceof Error ? error46.message : String(error46)}`);
@@ -59140,6 +58980,9 @@ PROFILE MANAGEMENT:
   claudish profile show    Show profile details (default profile or claudish profile show <name>)
   claudish profile edit    Edit a profile (interactive or claudish profile edit <name>)
 
+UPDATE:
+  claudish update          Check for updates and install latest version
+
 MODEL MAPPING (per-role override):
   --model-opus <model>     Model for Opus role (planning, complex tasks)
   --model-sonnet <model>   Model for Sonnet role (default coding)
@@ -59299,7 +59142,7 @@ MORE INFO:
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join13(__dirname6, "../AI_AGENT_GUIDE.md");
+    const guidePath = join12(__dirname6, "../AI_AGENT_GUIDE.md");
     const guideContent = readFileSync6(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
@@ -59316,10 +59159,10 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join13(cwd, ".claude");
-  const skillsDir = join13(claudeDir, "skills");
-  const claudishSkillDir = join13(skillsDir, "claudish-usage");
-  const skillFile = join13(claudishSkillDir, "SKILL.md");
+  const claudeDir = join12(cwd, ".claude");
+  const skillsDir = join12(claudeDir, "skills");
+  const claudishSkillDir = join12(skillsDir, "claudish-usage");
+  const skillFile = join12(claudishSkillDir, "SKILL.md");
   if (existsSync7(skillFile)) {
     console.log("✅ Claudish skill already installed at:");
     console.log(`   ${skillFile}
@@ -59327,7 +59170,7 @@ async function initializeClaudishSkill() {
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join13(__dirname6, "../skills/claudish-usage/SKILL.md");
+  const sourceSkillPath = join12(__dirname6, "../skills/claudish-usage/SKILL.md");
   if (!existsSync7(sourceSkillPath)) {
     console.error("❌ Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
@@ -59338,15 +59181,15 @@ async function initializeClaudishSkill() {
   }
   try {
     if (!existsSync7(claudeDir)) {
-      mkdirSync9(claudeDir, { recursive: true });
+      mkdirSync8(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
     if (!existsSync7(skillsDir)) {
-      mkdirSync9(skillsDir, { recursive: true });
+      mkdirSync8(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
     if (!existsSync7(claudishSkillDir)) {
-      mkdirSync9(claudishSkillDir, { recursive: true });
+      mkdirSync8(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync(sourceSkillPath, skillFile);
@@ -59440,7 +59283,7 @@ Force update: claudish --list-models --force-update
 `);
 }
 function printAvailableModelsJSON() {
-  const jsonPath = join13(__dirname6, "../recommended-models.json");
+  const jsonPath = join12(__dirname6, "../recommended-models.json");
   try {
     const jsonContent = readFileSync6(jsonPath, "utf-8");
     const data = JSON.parse(jsonContent);
@@ -59474,72 +59317,41 @@ var init_cli = __esm(() => {
   __filename6 = fileURLToPath5(import.meta.url);
   __dirname6 = dirname5(__filename6);
   try {
-    const packageJson = JSON.parse(readFileSync6(join13(__dirname6, "../package.json"), "utf-8"));
+    const packageJson = JSON.parse(readFileSync6(join12(__dirname6, "../package.json"), "utf-8"));
     VERSION = packageJson.version;
   } catch {}
-  MODELS_JSON_PATH = join13(__dirname6, "../recommended-models.json");
-  ALL_MODELS_JSON_PATH2 = join13(__dirname6, "../all-models.json");
-});
-
-// src/port-manager.ts
-var exports_port_manager = {};
-__export(exports_port_manager, {
-  isPortAvailable: () => isPortAvailable,
-  findAvailablePort: () => findAvailablePort
+  MODELS_JSON_PATH = join12(__dirname6, "../recommended-models.json");
+  ALL_MODELS_JSON_PATH2 = join12(__dirname6, "../all-models.json");
 });
-import { createServer } from "node:net";
-async function findAvailablePort(startPort = 3000, endPort = 9000) {
-  const randomPort = Math.floor(Math.random() * (endPort - startPort + 1)) + startPort;
-  if (await isPortAvailable(randomPort)) {
-    return randomPort;
-  }
-  for (let port = startPort;port <= endPort; port++) {
-    if (await isPortAvailable(port)) {
-      return port;
-    }
-  }
-  throw new Error(`No available ports found in range ${startPort}-${endPort}`);
-}
-async function isPortAvailable(port) {
-  return new Promise((resolve) => {
-    const server = createServer();
-    server.once("error", (err) => {
-      resolve(err.code !== "EADDRINUSE");
-    });
-    server.once("listening", () => {
-      server.close();
-      resolve(true);
-    });
-    server.listen(port, "127.0.0.1");
-  });
-}
-var init_port_manager = () => {};
 
 // src/update-checker.ts
 var exports_update_checker = {};
 __export(exports_update_checker, {
+  fetchLatestVersion: () => fetchLatestVersion,
+  compareVersions: () => compareVersions,
+  clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
 import { execSync } from "node:child_process";
+import { existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync7, unlinkSync, writeFileSync as writeFileSync11 } from "node:fs";
+import { homedir as homedir7, platform, tmpdir } from "node:os";
+import { join as join13 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
-import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync12, mkdirSync as mkdirSync10, unlinkSync as unlinkSync2 } from "node:fs";
-import { join as join14 } from "node:path";
-import { tmpdir as tmpdir2, homedir as homedir7, platform } from "node:os";
 function getCacheFilePath() {
   let cacheDir;
-  if (isWindows2) {
-    const localAppData = process.env.LOCALAPPDATA || join14(homedir7(), "AppData", "Local");
-    cacheDir = join14(localAppData, "claudish");
+  if (isWindows) {
+    const localAppData = process.env.LOCALAPPDATA || join13(homedir7(), "AppData", "Local");
+    cacheDir = join13(localAppData, "claudish");
   } else {
-    cacheDir = join14(homedir7(), ".cache", "claudish");
+    cacheDir = join13(homedir7(), ".cache", "claudish");
   }
   try {
     if (!existsSync8(cacheDir)) {
-      mkdirSync10(cacheDir, { recursive: true });
+      mkdirSync9(cacheDir, { recursive: true });
     }
-    return join14(cacheDir, "update-check.json");
+    return join13(cacheDir, "update-check.json");
   } catch {
-    return join14(tmpdir2(), "claudish-update-check.json");
+    return join13(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
@@ -59561,7 +59373,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync12(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync11(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {
@@ -59572,7 +59384,7 @@ function clearCache() {
   try {
     const cachePath = getCacheFilePath();
     if (existsSync8(cachePath)) {
-      unlinkSync2(cachePath);
+      unlinkSync(cachePath);
     }
   } catch {}
 }
@@ -59625,10 +59437,9 @@ function runUpdate() {
     console.error(`
 [claudish] Updating...
 `);
-    const result = execSync("npm install -g claudish@latest", {
+    execSync("npm install -g claudish@latest", {
       stdio: "inherit",
-      encoding: "utf-8",
-      shell: true
+      shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
     });
     console.error(`
 [claudish] Update complete! Please restart claudish.
@@ -59688,12 +59499,397 @@ async function checkForUpdates(currentVersion, options = {}) {
   }
   return false;
 }
-var isWindows2, NPM_REGISTRY_URL = "https://registry.npmjs.org/claudish/latest", CACHE_MAX_AGE_MS;
+var isWindows, NPM_REGISTRY_URL = "https://registry.npmjs.org/claudish/latest", CACHE_MAX_AGE_MS;
 var init_update_checker = __esm(() => {
-  isWindows2 = platform() === "win32";
+  isWindows = platform() === "win32";
   CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 });
 
+// src/update-command.ts
+var exports_update_command = {};
+__export(exports_update_command, {
+  updateCommand: () => updateCommand
+});
+import { execSync as execSync2 } from "node:child_process";
+import { createInterface as createInterface3 } from "node:readline";
+function detectInstallationMethod() {
+  const scriptPath = process.argv[1] || "";
+  if (scriptPath.includes("/opt/homebrew/") || scriptPath.includes("/usr/local/Cellar/")) {
+    return { method: "brew", path: scriptPath };
+  }
+  if (scriptPath.includes("/.bun/")) {
+    return { method: "bun", path: scriptPath };
+  }
+  if (scriptPath.includes("/node_modules/") || scriptPath.includes("/nvm/") || scriptPath.includes("/npm/")) {
+    return { method: "npm", path: scriptPath };
+  }
+  return { method: "unknown", path: scriptPath };
+}
+function getUpdateCommand(method) {
+  switch (method) {
+    case "npm":
+      return "npm install -g claudish@latest";
+    case "bun":
+      return "bun update -g claudish";
+    case "brew":
+      return "brew upgrade claudish";
+    case "unknown":
+      return "";
+  }
+}
+function promptUser2(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface3({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      const normalized = answer.toLowerCase().trim();
+      resolve(normalized === "y" || normalized === "yes" || normalized === "");
+    });
+  });
+}
+async function executeUpdate(command) {
+  try {
+    console.log(`
+${BOLD2}Updating...${RESET2}
+`);
+    execSync2(command, {
+      stdio: "inherit",
+      shell: process.platform === "win32" ? "cmd.exe" : "/bin/sh"
+    });
+    console.log(`
+${GREEN2}✓${RESET2} ${BOLD2}Update complete!${RESET2}`);
+    console.log(`${CYAN2}Please restart any running claudish sessions.${RESET2}
+`);
+    return true;
+  } catch (error46) {
+    console.error(`
+${RED}✗${RESET2} ${BOLD2}Update failed.${RESET2}`);
+    console.error(`${YELLOW2}Try manually:${RESET2}`);
+    console.error(`  ${command}
+`);
+    return false;
+  }
+}
+function printManualInstructions() {
+  console.log(`
+${BOLD2}Unable to detect installation method.${RESET2}`);
+  console.log(`${YELLOW2}Please update manually:${RESET2}
+`);
+  console.log(`  ${CYAN2}npm:${RESET2}  npm install -g claudish@latest`);
+  console.log(`  ${CYAN2}bun:${RESET2}  bun install -g claudish@latest`);
+  console.log(`  ${CYAN2}brew:${RESET2} brew upgrade claudish ${RED}(not yet available)${RESET2}
+`);
+}
+async function updateCommand() {
+  console.log(`
+${BOLD2}Checking for updates...${RESET2}
+`);
+  const currentVersion = getVersion();
+  const latestVersion = await fetchLatestVersion();
+  if (!latestVersion) {
+    console.error(`${RED}✗${RESET2} Unable to fetch latest version from npm registry.`);
+    console.error(`${YELLOW2}Please check your internet connection and try again.${RESET2}
+`);
+    process.exit(1);
+  }
+  const comparison = compareVersions(latestVersion, currentVersion);
+  if (comparison <= 0) {
+    console.log(`${GREEN2}✓${RESET2} ${BOLD2}Already up-to-date!${RESET2}`);
+    console.log(`${CYAN2}Current version: ${currentVersion}${RESET2}
+`);
+    process.exit(0);
+  }
+  console.log(`${BOLD2}Current version:${RESET2} ${YELLOW2}${currentVersion}${RESET2}`);
+  console.log(`${BOLD2}Latest version:${RESET2}  ${GREEN2}${latestVersion}${RESET2}
+`);
+  const installInfo = detectInstallationMethod();
+  if (installInfo.method === "unknown") {
+    printManualInstructions();
+    process.exit(1);
+  }
+  console.log(`${BOLD2}Detected installation method:${RESET2} ${CYAN2}${installInfo.method}${RESET2}`);
+  const command = getUpdateCommand(installInfo.method);
+  if (installInfo.method === "brew") {
+    console.log(`${RED}Note: Homebrew formula not yet published.${RESET2}
+`);
+    printManualInstructions();
+    process.exit(1);
+  }
+  console.log(`${BOLD2}Update command:${RESET2} ${command}
+`);
+  const shouldUpdate = await promptUser2(`${BOLD2}Proceed with update? [Y/n]${RESET2} `);
+  if (!shouldUpdate) {
+    console.log(`
+${YELLOW2}Update cancelled.${RESET2}`);
+    console.log(`${CYAN2}Update later with: ${command}${RESET2}
+`);
+    process.exit(0);
+  }
+  const success2 = await executeUpdate(command);
+  if (success2) {
+    clearCache();
+    process.exit(0);
+  } else {
+    process.exit(1);
+  }
+}
+var RESET2 = "\x1B[0m", BOLD2 = "\x1B[1m", GREEN2 = "\x1B[32m", YELLOW2 = "\x1B[33m", CYAN2 = "\x1B[36m", RED = "\x1B[31m";
+var init_update_command = __esm(() => {
+  init_cli();
+  init_update_checker();
+});
+
+// src/claude-runner.ts
+var exports_claude_runner = {};
+__export(exports_claude_runner, {
+  runClaudeWithProxy: () => runClaudeWithProxy,
+  checkClaudeInstalled: () => checkClaudeInstalled
+});
+import { spawn } from "node:child_process";
+import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync2, mkdirSync as mkdirSync10 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join14 } from "node:path";
+function isWindows2() {
+  return process.platform === "win32";
+}
+function createStatusLineScript(tokenFilePath) {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
+  const claudishDir = join14(homeDir, ".claudish");
+  const timestamp = Date.now();
+  const scriptPath = join14(claudishDir, `status-${timestamp}.js`);
+  const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
+  const script = `
+const fs = require('fs');
+const path = require('path');
+
+const CYAN = "\\x1b[96m";
+const YELLOW = "\\x1b[93m";
+const GREEN = "\\x1b[92m";
+const MAGENTA = "\\x1b[95m";
+const DIM = "\\x1b[2m";
+const RESET = "\\x1b[0m";
+const BOLD = "\\x1b[1m";
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    let dir = path.basename(process.cwd());
+    if (dir.length > 15) dir = dir.substring(0, 12) + '...';
+
+    let ctx = 100, cost = 0;
+    const model = process.env.CLAUDISH_ACTIVE_MODEL_NAME || 'unknown';
+    const isLocal = process.env.CLAUDISH_IS_LOCAL === 'true';
+
+    try {
+      const tokens = JSON.parse(fs.readFileSync('${escapedTokenPath}', 'utf-8'));
+      cost = tokens.total_cost || 0;
+      ctx = tokens.context_left_percent || 100;
+    } catch (e) {
+      try {
+        const json = JSON.parse(input);
+        cost = json.total_cost_usd || 0;
+      } catch {}
+    }
+
+    const costDisplay = isLocal ? 'LOCAL' : ('$' + cost.toFixed(3));
+    console.log(\`\${CYAN}\${BOLD}\${dir}\${RESET} \${DIM}•\${RESET} \${YELLOW}\${model}\${RESET} \${DIM}•\${RESET} \${GREEN}\${costDisplay}\${RESET} \${DIM}•\${RESET} \${MAGENTA}\${ctx}%\${RESET}\`);
+  } catch (e) {
+    console.log('claudish');
+  }
+});
+`;
+  writeFileSync12(scriptPath, script, "utf-8");
+  return scriptPath;
+}
+function createTempSettingsFile(modelDisplay, port) {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
+  const claudishDir = join14(homeDir, ".claudish");
+  try {
+    mkdirSync10(claudishDir, { recursive: true });
+  } catch {}
+  const timestamp = Date.now();
+  const tempPath = join14(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join14(claudishDir, `tokens-${port}.json`);
+  let statusCommand;
+  if (isWindows2()) {
+    const scriptPath = createStatusLineScript(tokenFilePath);
+    statusCommand = `node "${scriptPath}"`;
+  } else {
+    const CYAN3 = "\\033[96m";
+    const YELLOW3 = "\\033[93m";
+    const GREEN3 = "\\033[92m";
+    const MAGENTA = "\\033[95m";
+    const DIM2 = "\\033[2m";
+    const RESET3 = "\\033[0m";
+    const BOLD3 = "\\033[1m";
+    statusCommand = `JSON=$(cat) && DIR=$(basename "$(pwd)") && [ \${#DIR} -gt 15 ] && DIR="\${DIR:0:12}..." || true && CTX=100 && COST="0" && if [ -f "${tokenFilePath}" ]; then TOKENS=$(cat "${tokenFilePath}" 2>/dev/null) && REAL_CTX=$(echo "$TOKENS" | grep -o '"context_left_percent":[0-9]*' | grep -o '[0-9]*') && if [ ! -z "$REAL_CTX" ]; then CTX="$REAL_CTX"; fi && REAL_COST=$(echo "$TOKENS" | grep -o '"total_cost":[0-9.]*' | cut -d: -f2) && if [ ! -z "$REAL_COST" ]; then COST="$REAL_COST"; fi; fi && if [ "$CLAUDISH_IS_LOCAL" = "true" ]; then COST_DISPLAY="LOCAL"; else COST_DISPLAY=$(printf "\\$%.3f" "$COST"); fi && printf "${CYAN3}${BOLD3}%s${RESET3} ${DIM2}•${RESET3} ${YELLOW3}%s${RESET3} ${DIM2}•${RESET3} ${GREEN3}%s${RESET3} ${DIM2}•${RESET3} ${MAGENTA}%s%%${RESET3}\\n" "$DIR" "$CLAUDISH_ACTIVE_MODEL_NAME" "$COST_DISPLAY" "$CTX"`;
+  }
+  const settings = {
+    statusLine: {
+      type: "command",
+      command: statusCommand,
+      padding: 0
+    }
+  };
+  writeFileSync12(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  return tempPath;
+}
+async function runClaudeWithProxy(config3, proxyUrl) {
+  const modelId = config3.model || "unknown";
+  const portMatch = proxyUrl.match(/:(\d+)/);
+  const port = portMatch ? portMatch[1] : "unknown";
+  const tempSettingsPath = createTempSettingsFile(modelId, port);
+  const claudeArgs = [];
+  claudeArgs.push("--settings", tempSettingsPath);
+  if (config3.interactive) {
+    if (config3.autoApprove) {
+      claudeArgs.push("--dangerously-skip-permissions");
+    }
+    if (config3.dangerous) {
+      claudeArgs.push("--dangerouslyDisableSandbox");
+    }
+  } else {
+    claudeArgs.push("-p");
+    if (config3.autoApprove) {
+      claudeArgs.push("--dangerously-skip-permissions");
+    }
+    if (config3.dangerous) {
+      claudeArgs.push("--dangerouslyDisableSandbox");
+    }
+    if (config3.jsonOutput) {
+      claudeArgs.push("--output-format", "json");
+    }
+    if (config3.agent && config3.claudeArgs.length > 0) {
+      const modifiedArgs = [...config3.claudeArgs];
+      const agentId = config3.agent.startsWith("@agent-") ? config3.agent : `@agent-${config3.agent}`;
+      modifiedArgs[0] = `Use the ${agentId} agent to: ${modifiedArgs[0]}`;
+      claudeArgs.push(...modifiedArgs);
+    } else {
+      claudeArgs.push(...config3.claudeArgs);
+    }
+  }
+  const isLocalModel = modelId.startsWith("ollama/") || modelId.startsWith("ollama:") || modelId.startsWith("lmstudio/") || modelId.startsWith("lmstudio:") || modelId.startsWith("vllm/") || modelId.startsWith("vllm:") || modelId.startsWith("mlx/") || modelId.startsWith("mlx:") || modelId.startsWith("http://") || modelId.startsWith("https://");
+  const env = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: proxyUrl,
+    [ENV.CLAUDISH_ACTIVE_MODEL_NAME]: modelId,
+    CLAUDISH_IS_LOCAL: isLocalModel ? "true" : "false",
+    [ENV.ANTHROPIC_MODEL]: modelId,
+    [ENV.ANTHROPIC_SMALL_FAST_MODEL]: modelId
+  };
+  if (config3.monitor) {
+    delete env.ANTHROPIC_API_KEY;
+  } else {
+    env.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx";
+  }
+  const log2 = (message) => {
+    if (!config3.quiet) {
+      console.log(message);
+    }
+  };
+  if (config3.interactive) {
+    log2(`
+[claudish] Model: ${modelId}
+`);
+  } else {
+    log2(`
+[claudish] Model: ${modelId}`);
+    log2(`[claudish] Arguments: ${claudeArgs.join(" ")}
+`);
+  }
+  const proc = spawn("claude", claudeArgs, {
+    env,
+    stdio: "inherit",
+    shell: isWindows2()
+  });
+  setupSignalHandlers(proc, tempSettingsPath, config3.quiet);
+  const exitCode = await new Promise((resolve) => {
+    proc.on("exit", (code) => {
+      resolve(code ?? 1);
+    });
+  });
+  try {
+    unlinkSync2(tempSettingsPath);
+  } catch (error46) {}
+  return exitCode;
+}
+function setupSignalHandlers(proc, tempSettingsPath, quiet) {
+  const signals2 = isWindows2() ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
+  for (const signal of signals2) {
+    process.on(signal, () => {
+      if (!quiet) {
+        console.log(`
+[claudish] Received ${signal}, shutting down...`);
+      }
+      proc.kill();
+      try {
+        unlinkSync2(tempSettingsPath);
+      } catch {}
+      process.exit(0);
+    });
+  }
+}
+async function checkClaudeInstalled() {
+  try {
+    const isWindows3 = process.platform === "win32";
+    const command = isWindows3 ? "where" : "which";
+    const proc = spawn(command, ["claude"], {
+      stdio: "ignore",
+      shell: isWindows3
+    });
+    const exitCode = await new Promise((resolve) => {
+      proc.on("exit", (code) => {
+        resolve(code ?? 1);
+      });
+    });
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+var init_claude_runner = __esm(() => {
+  init_dist11();
+});
+
+// src/port-manager.ts
+var exports_port_manager = {};
+__export(exports_port_manager, {
+  isPortAvailable: () => isPortAvailable,
+  findAvailablePort: () => findAvailablePort
+});
+import { createServer } from "node:net";
+async function findAvailablePort(startPort = 3000, endPort = 9000) {
+  const randomPort = Math.floor(Math.random() * (endPort - startPort + 1)) + startPort;
+  if (await isPortAvailable(randomPort)) {
+    return randomPort;
+  }
+  for (let port = startPort;port <= endPort; port++) {
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available ports found in range ${startPort}-${endPort}`);
+}
+async function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", (err) => {
+      resolve(err.code !== "EADDRINUSE");
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+var init_port_manager = () => {};
+
 // src/index.ts
 var import_dotenv2 = __toESM(require_main(), 1);
 import_dotenv2.config({ quiet: true });
@@ -59706,6 +59902,8 @@ if (isMcpMode) {
   Promise.resolve().then(() => (init_profile_commands(), exports_profile_commands)).then((pc) => pc.initCommand());
 } else if (firstArg === "profile") {
   Promise.resolve().then(() => (init_profile_commands(), exports_profile_commands)).then((pc) => pc.profileCommand(args.slice(1)));
+} else if (firstArg === "update") {
+  Promise.resolve().then(() => (init_update_command(), exports_update_command)).then((uc) => uc.updateCommand());
 } else {
   runCli();
 }