claudish 5.14.0 → 5.16.0

package/dist/index.js

@@ -28416,19 +28416,379 @@ var init_stdio2 = __esm(() => {
   init_stdio();
 });
 
+// src/team-orchestrator.ts
+import { spawn } from "child_process";
+import {
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  readdirSync,
+  statSync,
+  createWriteStream
+} from "fs";
+import { join, resolve } from "path";
+function validateSessionPath(sessionPath) {
+  const resolved = resolve(sessionPath);
+  const cwd = process.cwd();
+  if (!resolved.startsWith(cwd + "/") && resolved !== cwd) {
+    throw new Error(`Session path must be within current directory: ${sessionPath}`);
+  }
+  return resolved;
+}
+function setupSession(sessionPath, models, input) {
+  if (models.length === 0) {
+    throw new Error("At least one model is required");
+  }
+  mkdirSync(join(sessionPath, "work"), { recursive: true });
+  mkdirSync(join(sessionPath, "errors"), { recursive: true });
+  if (input !== undefined) {
+    writeFileSync(join(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync(join(sessionPath, "input.md"))) {
+    throw new Error(`No input.md found at ${sessionPath} and no input provided`);
+  }
+  const ids = models.map((_, i) => String(i + 1).padStart(2, "0"));
+  const shuffled = fisherYatesShuffle([...ids]);
+  const now = new Date().toISOString();
+  const manifest = {
+    created: now,
+    models: {},
+    shuffleOrder: shuffled
+  };
+  for (let i = 0;i < models.length; i++) {
+    const anonId = shuffled[i];
+    manifest.models[anonId] = {
+      model: models[i],
+      assignedAt: now
+    };
+    mkdirSync(join(sessionPath, "work", anonId), { recursive: true });
+  }
+  writeFileSync(join(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  const status = {
+    startedAt: now,
+    models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
+      id,
+      {
+        state: "PENDING",
+        exitCode: null,
+        startedAt: null,
+        completedAt: null,
+        outputSize: 0
+      }
+    ]))
+  };
+  writeFileSync(join(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  return manifest;
+}
+async function runModels(sessionPath, opts = {}) {
+  const timeoutMs = (opts.timeout ?? 300) * 1000;
+  const manifest = JSON.parse(readFileSync(join(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join(sessionPath, "status.json");
+  const inputPath = join(sessionPath, "input.md");
+  const inputContent = readFileSync(inputPath, "utf-8");
+  const statusCache = JSON.parse(readFileSync(statusPath, "utf-8"));
+  function updateModelStatus(id, update) {
+    statusCache.models[id] = { ...statusCache.models[id], ...update };
+    writeFileSync(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
+  }
+  const processes = new Map;
+  const sigintHandler = () => {
+    for (const [, proc] of processes) {
+      if (!proc.killed)
+        proc.kill("SIGTERM");
+    }
+    process.exit(1);
+  };
+  process.on("SIGINT", sigintHandler);
+  const completionPromises = [];
+  for (const [anonId, entry] of Object.entries(manifest.models)) {
+    const outputPath = join(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join(sessionPath, "errors", `${anonId}.log`);
+    const workDir = join(sessionPath, "work", anonId);
+    const args = [
+      "--model",
+      entry.model,
+      "-y",
+      "--stdin",
+      "--quiet",
+      ...opts.claudeFlags ?? []
+    ];
+    updateModelStatus(anonId, {
+      state: "RUNNING",
+      startedAt: new Date().toISOString()
+    });
+    const proc = spawn("claudish", args, {
+      cwd: workDir,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: false
+    });
+    const outputStream = createWriteStream(outputPath);
+    proc.stdout?.pipe(outputStream);
+    let stderr = "";
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    proc.stdin?.write(inputContent);
+    proc.stdin?.end();
+    const completionPromise = new Promise((resolve2) => {
+      let exitCode = null;
+      let resolved = false;
+      const finish = () => {
+        if (resolved)
+          return;
+        resolved = true;
+        let outputSize = 0;
+        try {
+          outputSize = statSync(outputPath).size;
+        } catch {}
+        updateModelStatus(anonId, {
+          state: exitCode === 0 ? "COMPLETED" : "FAILED",
+          exitCode: exitCode ?? 1,
+          completedAt: new Date().toISOString(),
+          outputSize
+        });
+        opts.onStatusChange?.(anonId, statusCache.models[anonId]);
+        resolve2();
+      };
+      outputStream.on("close", finish);
+      proc.on("exit", (code) => {
+        const current = statusCache.models[anonId];
+        if (current?.state === "TIMEOUT") {
+          resolved = true;
+          resolve2();
+          return;
+        }
+        if (stderr) {
+          writeFileSync(errorLogPath, stderr, "utf-8");
+        }
+        exitCode = code;
+        if (outputStream.destroyed) {
+          finish();
+        }
+      });
+    });
+    processes.set(anonId, proc);
+    completionPromises.push(completionPromise);
+  }
+  let timeoutHandle = null;
+  await Promise.race([
+    Promise.all(completionPromises),
+    new Promise((resolve2) => {
+      timeoutHandle = setTimeout(() => {
+        for (const [id, proc] of processes) {
+          if (!proc.killed) {
+            proc.kill("SIGTERM");
+            updateModelStatus(id, {
+              state: "TIMEOUT",
+              completedAt: new Date().toISOString()
+            });
+            opts.onStatusChange?.(id, statusCache.models[id]);
+          }
+        }
+        resolve2();
+      }, timeoutMs);
+    })
+  ]);
+  if (timeoutHandle !== null)
+    clearTimeout(timeoutHandle);
+  process.off("SIGINT", sigintHandler);
+  return statusCache;
+}
+async function judgeResponses(sessionPath, opts = {}) {
+  const responseFiles = readdirSync(sessionPath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
+  if (responseFiles.length < 2) {
+    throw new Error(`Need at least 2 responses to judge, found ${responseFiles.length}`);
+  }
+  const responses = {};
+  for (const file2 of responseFiles) {
+    const id = file2.replace(/^response-/, "").replace(/\.md$/, "");
+    responses[id] = readFileSync(join(sessionPath, file2), "utf-8");
+  }
+  const input = readFileSync(join(sessionPath, "input.md"), "utf-8");
+  const judgePrompt = buildJudgePrompt(input, responses);
+  writeFileSync(join(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
+  const judgePath = join(sessionPath, "judging");
+  mkdirSync(judgePath, { recursive: true });
+  setupSession(judgePath, judgeModels, judgePrompt);
+  await runModels(judgePath, { claudeFlags: opts.claudeFlags });
+  const votes = parseJudgeVotes(judgePath, Object.keys(responses));
+  const verdict = aggregateVerdict(votes, Object.keys(responses));
+  writeFileSync(join(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  return verdict;
+}
+function getStatus(sessionPath) {
+  return JSON.parse(readFileSync(join(sessionPath, "status.json"), "utf-8"));
+}
+function fisherYatesShuffle(arr) {
+  for (let i = arr.length - 1;i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+function getDefaultJudgeModels(sessionPath) {
+  const manifest = JSON.parse(readFileSync(join(sessionPath, "manifest.json"), "utf-8"));
+  return Object.values(manifest.models).map((e) => e.model);
+}
+function buildJudgePrompt(input, responses) {
+  const ids = Object.keys(responses).sort();
+  let prompt = `## Blind Evaluation Task
+
+`;
+  prompt += `### Original Task
+
+`;
+  prompt += input + `
+
+`;
+  prompt += `---
+
+`;
+  prompt += `### Responses to Evaluate
+
+`;
+  prompt += `Evaluate each response independently. You do not know which model produced which response.
+
+`;
+  for (const id of ids) {
+    prompt += `#### Response ${id}
+
+`;
+    prompt += responses[id] + `
+
+`;
+    prompt += `---
+
+`;
+  }
+  prompt += `### Your Assignment
+
+`;
+  prompt += `For EACH of the ${ids.length} responses above, provide a vote block in this exact format:
+
+`;
+  prompt += "```vote\n";
+  prompt += `RESPONSE: [ID]
+`;
+  prompt += `VERDICT: [APPROVE|REJECT|ABSTAIN]
+`;
+  prompt += `CONFIDENCE: [1-10]
+`;
+  prompt += `SUMMARY: [One sentence]
+`;
+  prompt += `KEY_ISSUES: [Comma-separated issues, or None]
+`;
+  prompt += "```\n\n";
+  prompt += `Provide exactly ${ids.length} vote blocks, one per response. Be decisive and analytical.
+`;
+  return prompt;
+}
+function parseJudgeVotes(judgePath, responseIds) {
+  const votes = [];
+  const responseFiles = readdirSync(judgePath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
+  for (const file2 of responseFiles) {
+    const judgeId = file2.replace(/^response-/, "").replace(/\.md$/, "");
+    let content;
+    try {
+      content = readFileSync(join(judgePath, file2), "utf-8");
+    } catch {
+      continue;
+    }
+    const votePattern = /```vote\s*\n([\s\S]*?)\n\s*```/g;
+    let match;
+    while ((match = votePattern.exec(content)) !== null) {
+      const block = match[1];
+      const responseMatch = block.match(/RESPONSE:\s*(\S+)/);
+      const verdictMatch = block.match(/VERDICT:\s*(APPROVE|REJECT|ABSTAIN)/);
+      const confidenceMatch = block.match(/CONFIDENCE:\s*(\d+)/);
+      const summaryMatch = block.match(/SUMMARY:\s*(.+)/);
+      const keyIssuesMatch = block.match(/KEY_ISSUES:\s*(.+)/);
+      const responseId = responseMatch?.[1];
+      const verdict = verdictMatch?.[1];
+      if (!responseId || !verdict)
+        continue;
+      if (!responseIds.includes(responseId))
+        continue;
+      votes.push({
+        judgeId,
+        responseId,
+        verdict,
+        confidence: parseInt(confidenceMatch?.[1] ?? "5", 10),
+        summary: summaryMatch?.[1]?.trim() ?? "",
+        keyIssues: keyIssuesMatch?.[1]?.split(",").map((s) => s.trim()).filter((s) => s.toLowerCase() !== "none" && s.length > 0) ?? []
+      });
+    }
+  }
+  return votes;
+}
+function aggregateVerdict(votes, responseIds) {
+  const responses = {};
+  for (const id of responseIds) {
+    const votesForResponse = votes.filter((v) => v.responseId === id);
+    const approvals = votesForResponse.filter((v) => v.verdict === "APPROVE").length;
+    const rejections = votesForResponse.filter((v) => v.verdict === "REJECT").length;
+    const abstentions = votesForResponse.filter((v) => v.verdict === "ABSTAIN").length;
+    const total = approvals + rejections;
+    responses[id] = {
+      approvals,
+      rejections,
+      abstentions,
+      score: total > 0 ? approvals / total : 0
+    };
+  }
+  const ranking = Object.entries(responses).sort(([, a], [, b]) => b.score - a.score).map(([id]) => id);
+  return { responses, ranking, votes };
+}
+function formatVerdict(verdict, sessionPath) {
+  let manifest = null;
+  try {
+    manifest = JSON.parse(readFileSync(join(sessionPath, "manifest.json"), "utf-8"));
+  } catch {}
+  let output = `# Team Verdict
+
+`;
+  output += `## Ranking
+
+`;
+  output += `| Rank | Response | Model | Score | Approvals | Rejections | Abstentions |
+`;
+  output += `|------|----------|-------|-------|-----------|------------|-------------|
+`;
+  for (let i = 0;i < verdict.ranking.length; i++) {
+    const id = verdict.ranking[i];
+    const r = verdict.responses[id];
+    const modelName = manifest?.models[id]?.model ?? "unknown";
+    const scoreStr = `${(r.score * 100).toFixed(0)}%`;
+    output += `| ${i + 1} | ${id} | ${modelName} | ${scoreStr} | ${r.approvals} | ${r.rejections} | ${r.abstentions} |
+`;
+  }
+  output += `
+## Individual Votes
+
+`;
+  for (const vote of verdict.votes) {
+    const issueStr = vote.keyIssues.length > 0 ? ` Issues: ${vote.keyIssues.join(", ")}.` : "";
+    output += `- **Judge ${vote.judgeId}** -> Response ${vote.responseId}: **${vote.verdict}** (${vote.confidence}/10) \u2014 ${vote.summary}${issueStr}
+`;
+  }
+  return output;
+}
+var init_team_orchestrator = () => {};
+
 // src/mcp-server.ts
 var exports_mcp_server = {};
 __export(exports_mcp_server, {
   startMcpServer: () => startMcpServer
 });
-import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, dirname } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
 function loadRecommendedModels() {
-  if (existsSync(RECOMMENDED_MODELS_PATH)) {
+  if (existsSync2(RECOMMENDED_MODELS_PATH)) {
     try {
-      const data = JSON.parse(readFileSync(RECOMMENDED_MODELS_PATH, "utf-8"));
+      const data = JSON.parse(readFileSync2(RECOMMENDED_MODELS_PATH, "utf-8"));
       return data.models || [];
     } catch {
       return [];
@@ -28437,9 +28797,9 @@ function loadRecommendedModels() {
   return [];
 }
 async function loadAllModels(forceRefresh = false) {
-  if (!forceRefresh && existsSync(ALL_MODELS_CACHE_PATH)) {
+  if (!forceRefresh && existsSync2(ALL_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync(ALL_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync2(ALL_MODELS_CACHE_PATH, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const ageInDays = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
       if (ageInDays <= CACHE_MAX_AGE_DAYS) {
@@ -28453,15 +28813,15 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync(CLAUDISH_CACHE_DIR, { recursive: true });
-    writeFileSync(ALL_MODELS_CACHE_PATH, JSON.stringify({
+    mkdirSync2(CLAUDISH_CACHE_DIR, { recursive: true });
+    writeFileSync2(ALL_MODELS_CACHE_PATH, JSON.stringify({
       lastUpdated: new Date().toISOString(),
       models
     }), "utf-8");
     return models;
   } catch (error46) {
-    if (existsSync(ALL_MODELS_CACHE_PATH)) {
-      const cacheData = JSON.parse(readFileSync(ALL_MODELS_CACHE_PATH, "utf-8"));
+    if (existsSync2(ALL_MODELS_CACHE_PATH)) {
+      const cacheData = JSON.parse(readFileSync2(ALL_MODELS_CACHE_PATH, "utf-8"));
       return cacheData.models || [];
     }
     return [];
@@ -28488,7 +28848,7 @@ async function runPrompt(model, prompt, systemPrompt, maxTokens) {
     body: JSON.stringify({
       model,
       messages,
-      max_tokens: maxTokens || 4096
+      ...maxTokens ? { max_tokens: maxTokens } : {}
     })
   });
   if (!response.ok) {
@@ -28526,7 +28886,7 @@ async function main() {
     model: exports_external.string().describe("OpenRouter model ID (e.g., 'x-ai/grok-code-fast-1', 'openai/gpt-5.1-codex')"),
     prompt: exports_external.string().describe("The prompt to send to the model"),
     system_prompt: exports_external.string().optional().describe("Optional system prompt"),
-    max_tokens: exports_external.number().optional().describe("Maximum tokens in response (default: 4096)")
+    max_tokens: exports_external.number().optional().describe("Maximum tokens in response (omit to let model decide)")
   }, async ({ model, prompt, system_prompt, max_tokens }) => {
     try {
       const result = await runPrompt(model, prompt, system_prompt, max_tokens);
@@ -28633,12 +28993,13 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
   server.tool("compare_models", "Run the same prompt through multiple models and compare responses", {
     models: exports_external.array(exports_external.string()).describe("List of model IDs to compare"),
     prompt: exports_external.string().describe("The prompt to send to all models"),
-    system_prompt: exports_external.string().optional().describe("Optional system prompt")
-  }, async ({ models, prompt, system_prompt }) => {
+    system_prompt: exports_external.string().optional().describe("Optional system prompt"),
+    max_tokens: exports_external.number().optional().describe("Maximum tokens in response (omit to let model decide)")
+  }, async ({ models, prompt, system_prompt, max_tokens }) => {
     const results = [];
     for (const model of models) {
       try {
-        const result = await runPrompt(model, prompt, system_prompt, 2048);
+        const result = await runPrompt(model, prompt, system_prompt, max_tokens);
         results.push({
           model,
           response: result.content,
@@ -28682,6 +29043,93 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
     }
     return { content: [{ type: "text", text: output }] };
   });
+  server.tool("team_run", "Run multiple AI models on a task and produce anonymized outputs in a session directory", {
+    path: exports_external.string().describe("Session directory path (must be within current working directory)"),
+    models: exports_external.array(exports_external.string()).describe("Model IDs to run (e.g., ['minimax-m2.5', 'kimi-k2.5'])"),
+    input: exports_external.string().optional().describe("Task prompt text (or place input.md in the session directory before calling)"),
+    timeout: exports_external.number().optional().describe("Per-model timeout in seconds (default: 300)")
+  }, async ({ path, models, input, timeout }) => {
+    try {
+      const resolved = validateSessionPath(path);
+      setupSession(resolved, models, input);
+      const status = await runModels(resolved, { timeout });
+      return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+    } catch (error46) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error46 instanceof Error ? error46.message : String(error46)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  server.tool("team_judge", "Blind-judge existing anonymized model outputs in a session directory", {
+    path: exports_external.string().describe("Session directory containing response-*.md files (must be within current working directory)"),
+    judges: exports_external.array(exports_external.string()).optional().describe("Model IDs to use as judges (default: same models that produced the responses)")
+  }, async ({ path, judges }) => {
+    try {
+      const resolved = validateSessionPath(path);
+      const verdict = await judgeResponses(resolved, { judges });
+      return { content: [{ type: "text", text: JSON.stringify(verdict, null, 2) }] };
+    } catch (error46) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error46 instanceof Error ? error46.message : String(error46)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  server.tool("team_run_and_judge", "Run multiple AI models on a task, then blind-judge their outputs \u2014 full pipeline", {
+    path: exports_external.string().describe("Session directory path (must be within current working directory)"),
+    models: exports_external.array(exports_external.string()).describe("Model IDs to run"),
+    judges: exports_external.array(exports_external.string()).optional().describe("Model IDs to use as judges (default: same as runners)"),
+    input: exports_external.string().optional().describe("Task prompt text"),
+    timeout: exports_external.number().optional().describe("Per-model timeout in seconds (default: 300)")
+  }, async ({ path, models, judges, input, timeout }) => {
+    try {
+      const resolved = validateSessionPath(path);
+      setupSession(resolved, models, input);
+      await runModels(resolved, { timeout });
+      const verdict = await judgeResponses(resolved, { judges });
+      return { content: [{ type: "text", text: JSON.stringify(verdict, null, 2) }] };
+    } catch (error46) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error46 instanceof Error ? error46.message : String(error46)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  server.tool("team_status", "Check the execution status of a team orchestrator session", {
+    path: exports_external.string().describe("Session directory path (must be within current working directory)")
+  }, async ({ path }) => {
+    try {
+      const resolved = validateSessionPath(path);
+      const status = getStatus(resolved);
+      return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+    } catch (error46) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error46 instanceof Error ? error46.message : String(error46)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
   const transport = new StdioServerTransport;
   await server.connect(transport);
   console.error("[claudish] MCP server started");
@@ -28697,21 +29145,24 @@ var init_mcp_server = __esm(() => {
   init_mcp();
   init_stdio2();
   init_zod();
+  init_team_orchestrator();
   import_dotenv = __toESM(require_main(), 1);
   import_dotenv.config();
   __filename2 = fileURLToPath(import.meta.url);
   __dirname2 = dirname(__filename2);
-  RECOMMENDED_MODELS_PATH = join(__dirname2, "../recommended-models.json");
-  CLAUDISH_CACHE_DIR = join(homedir(), ".claudish");
-  ALL_MODELS_CACHE_PATH = join(CLAUDISH_CACHE_DIR, "all-models.json");
+  RECOMMENDED_MODELS_PATH = join2(__dirname2, "../recommended-models.json");
+  CLAUDISH_CACHE_DIR = join2(homedir(), ".claudish");
+  ALL_MODELS_CACHE_PATH = join2(CLAUDISH_CACHE_DIR, "all-models.json");
 });
 
 // src/logger.ts
 var exports_logger = {};
 __export(exports_logger, {
   truncateContent: () => truncateContent,
+  structuralRedact: () => structuralRedact,
   setStderrQuiet: () => setStderrQuiet,
   setLogLevel: () => setLogLevel,
+  setDiagOutput: () => setDiagOutput,
   maskCredential: () => maskCredential,
   logStructured: () => logStructured,
   logStderr: () => logStderr,
@@ -28719,10 +29170,12 @@ __export(exports_logger, {
   isLoggingEnabled: () => isLoggingEnabled,
   initLogger: () => initLogger,
   getLogLevel: () => getLogLevel,
-  getLogFilePath: () => getLogFilePath
+  getLogFilePath: () => getLogFilePath,
+  getAlwaysOnLogPath: () => getAlwaysOnLogPath
 });
-import { writeFileSync as writeFileSync2, appendFile, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join2 } from "path";
+import { writeFileSync as writeFileSync3, appendFile, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
 function flushLogBuffer() {
   if (!logFilePath || logBuffer.length === 0)
     return;
@@ -28734,11 +29187,19 @@ function flushLogBuffer() {
     }
   });
 }
+function flushAlwaysOnBuffer() {
+  if (!alwaysOnLogPath || alwaysOnBuffer.length === 0)
+    return;
+  const toWrite = alwaysOnBuffer.join("");
+  alwaysOnBuffer = [];
+  appendFile(alwaysOnLogPath, toWrite, () => {});
+}
 function scheduleFlush() {
   if (flushTimer)
     return;
   flushTimer = setInterval(() => {
     flushLogBuffer();
+    flushAlwaysOnBuffer();
   }, FLUSH_INTERVAL_MS);
   process.on("exit", () => {
     if (flushTimer) {
@@ -28746,33 +29207,106 @@ function scheduleFlush() {
       flushTimer = null;
     }
     if (logFilePath && logBuffer.length > 0) {
-      writeFileSync2(logFilePath, logBuffer.join(""), { flag: "a" });
+      writeFileSync3(logFilePath, logBuffer.join(""), { flag: "a" });
       logBuffer = [];
     }
+    if (alwaysOnLogPath && alwaysOnBuffer.length > 0) {
+      writeFileSync3(alwaysOnLogPath, alwaysOnBuffer.join(""), { flag: "a" });
+      alwaysOnBuffer = [];
+    }
   });
 }
-function initLogger(debugMode, level = "info") {
-  if (!debugMode) {
-    logFilePath = null;
-    if (flushTimer) {
-      clearInterval(flushTimer);
-      flushTimer = null;
+function rotateOldLogs(dir, keep) {
+  try {
+    const files = readdirSync2(dir).filter((f) => f.startsWith("claudish_") && f.endsWith(".log")).sort().reverse();
+    for (const file2 of files.slice(keep)) {
+      try {
+        unlinkSync(join3(dir, file2));
+      } catch {}
     }
-    return;
+  } catch {}
+}
+function structuralRedact(jsonStr) {
+  try {
+    const obj = JSON.parse(jsonStr);
+    return JSON.stringify(redactDeep(obj));
+  } catch {
+    return jsonStr.replace(/"[^"]{20,}"/g, (m) => `"<${m.length - 2} chars>"`);
   }
-  logLevel = level;
-  const logsDir = join2(process.cwd(), "logs");
-  if (!existsSync2(logsDir)) {
-    mkdirSync2(logsDir, { recursive: true });
+}
+function redactDeep(val, key) {
+  if (val === null || val === undefined)
+    return val;
+  if (typeof val === "boolean" || typeof val === "number")
+    return val;
+  if (typeof val === "string") {
+    if (key && CONTENT_KEYS.has(key)) {
+      return `<${val.length} chars>`;
+    }
+    return val.length <= 20 ? val : `<${val.length} chars>`;
+  }
+  if (Array.isArray(val))
+    return val.map((v) => redactDeep(v));
+  if (typeof val === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(val)) {
+      result[k] = redactDeep(v, k);
+    }
+    return result;
+  }
+  return val;
+}
+function isStructuralLogWorthy(msg) {
+  return msg.startsWith("[SSE:") || msg.startsWith("[Proxy]") || msg.startsWith("[Fallback]") || msg.startsWith("[Streaming] ===") || msg.startsWith("[Streaming] Chunk:") || msg.startsWith("[Streaming] Received") || msg.startsWith("[Streaming] Text-based tool calls") || msg.startsWith("[Streaming] Final usage") || msg.startsWith("[Streaming] Sending") || msg.startsWith("[AnthropicSSE] Stream complete") || msg.startsWith("[AnthropicSSE] Tool use:") || msg.includes("Response status:") || msg.includes("Error") || msg.includes("error") || msg.includes("[Auto-route]");
+}
+function redactLogLine(message, timestamp) {
+  if (message.startsWith("[SSE:")) {
+    const prefixEnd = message.indexOf("] ") + 2;
+    const prefix = message.substring(0, prefixEnd);
+    const payload = message.substring(prefixEnd);
+    return `[${timestamp}] ${prefix}${structuralRedact(payload)}
+`;
   }
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
-  logFilePath = join2(logsDir, `claudish_${timestamp}.log`);
-  writeFileSync2(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
+  return `[${timestamp}] ${message}
+`;
+}
+function initLogger(debugMode, level = "info", noLogs = false) {
+  if (!noLogs) {
+    const logsDir = join3(homedir2(), ".claudish", "logs");
+    if (!existsSync3(logsDir)) {
+      mkdirSync3(logsDir, { recursive: true });
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
+    alwaysOnLogPath = join3(logsDir, `claudish_${timestamp}.log`);
+    writeFileSync3(alwaysOnLogPath, `Claudish Session Log - ${new Date().toISOString()}
+Mode: structural (content redacted)
+${"=".repeat(60)}
+
+`);
+    rotateOldLogs(logsDir, 20);
+    scheduleFlush();
+  }
+  if (debugMode) {
+    logLevel = level;
+    const logsDir = join3(process.cwd(), "logs");
+    if (!existsSync3(logsDir)) {
+      mkdirSync3(logsDir, { recursive: true });
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
+    logFilePath = join3(logsDir, `claudish_${timestamp}.log`);
+    writeFileSync3(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
 Log Level: ${level}
 ${"=".repeat(80)}
 
 `);
-  scheduleFlush();
+    scheduleFlush();
+  } else {
+    logFilePath = null;
+    if (noLogs && flushTimer) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    }
+  }
 }
 function log(message, forceConsole = false) {
   const timestamp = new Date().toISOString();
@@ -28784,25 +29318,40 @@ function log(message, forceConsole = false) {
       flushLogBuffer();
     }
   }
+  if (alwaysOnLogPath && isStructuralLogWorthy(message)) {
+    const redactedLine = redactLogLine(message, timestamp);
+    alwaysOnBuffer.push(redactedLine);
+    if (alwaysOnBuffer.length >= MAX_BUFFER_SIZE) {
+      flushAlwaysOnBuffer();
+    }
+  }
   if (forceConsole) {
     console.log(message);
   }
 }
 function logStderr(message) {
-  if (!stderrQuiet) {
+  if (diagOutput) {
+    diagOutput.write(message);
+  } else if (!stderrQuiet) {
     process.stderr.write(`[claudish] ${message}
 `);
   }
   log(message);
 }
+function setDiagOutput(output) {
+  diagOutput = output;
+}
 function setStderrQuiet(quiet) {
   stderrQuiet = quiet;
 }
 function getLogFilePath() {
   return logFilePath;
 }
+function getAlwaysOnLogPath() {
+  return alwaysOnLogPath;
+}
 function isLoggingEnabled() {
-  return logFilePath !== null;
+  return logFilePath !== null || alwaysOnLogPath !== null;
 }
 function maskCredential(credential) {
   if (!credential || credential.length <= 8) {
@@ -28849,9 +29398,19 @@ function logStructured(label, data) {
   }
   log(`[${label}] ${JSON.stringify(data, null, 2)}`);
 }
-var logFilePath = null, logLevel = "info", stderrQuiet = false, logBuffer, flushTimer = null, FLUSH_INTERVAL_MS = 100, MAX_BUFFER_SIZE = 50;
+var logFilePath = null, logLevel = "info", stderrQuiet = false, diagOutput = null, logBuffer, flushTimer = null, FLUSH_INTERVAL_MS = 100, MAX_BUFFER_SIZE = 50, alwaysOnLogPath = null, alwaysOnBuffer, CONTENT_KEYS;
 var init_logger = __esm(() => {
   logBuffer = [];
+  alwaysOnBuffer = [];
+  CONTENT_KEYS = new Set([
+    "content",
+    "reasoning_content",
+    "text",
+    "thinking",
+    "partial_json",
+    "arguments",
+    "input"
+  ]);
 });
 
 // src/auth/gemini-oauth.ts
@@ -28864,9 +29423,9 @@ __export(exports_gemini_oauth, {
 });
 import { createServer } from "http";
 import { randomBytes, createHash } from "crypto";
-import { readFileSync as readFileSync2, existsSync as existsSync3, unlinkSync, openSync, writeSync, closeSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync4, unlinkSync as unlinkSync2, openSync, writeSync, closeSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 
@@ -28889,8 +29448,8 @@ class GeminiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join3(homedir2(), ".claudish");
-    return join3(claudishDir, "gemini-oauth.json");
+    const claudishDir = join4(homedir3(), ".claudish");
+    return join4(claudishDir, "gemini-oauth.json");
   }
   async login() {
     log("[GeminiOAuth] Starting OAuth login flow");
@@ -28911,8 +29470,8 @@ class GeminiOAuth {
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync3(credPath)) {
-      unlinkSync(credPath);
+    if (existsSync4(credPath)) {
+      unlinkSync2(credPath);
       log("[GeminiOAuth] Credentials deleted");
     }
     this.credentials = null;
@@ -28988,11 +29547,11 @@ Details: ${e.message}`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync3(credPath)) {
+    if (!existsSync4(credPath)) {
       return null;
     }
     try {
-      const data = readFileSync2(credPath, "utf-8");
+      const data = readFileSync3(credPath, "utf-8");
       const credentials = JSON.parse(data);
       if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at) {
         log("[GeminiOAuth] Invalid credentials file structure");
@@ -29007,10 +29566,10 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join3(homedir2(), ".claudish");
-    if (!existsSync3(claudishDir)) {
-      const { mkdirSync: mkdirSync3 } = __require("fs");
-      mkdirSync3(claudishDir, { recursive: true });
+    const claudishDir = join4(homedir3(), ".claudish");
+    if (!existsSync4(claudishDir)) {
+      const { mkdirSync: mkdirSync4 } = __require("fs");
+      mkdirSync4(claudishDir, { recursive: true });
     }
     const fd = openSync(credPath, "w", 384);
     try {
@@ -29043,7 +29602,7 @@ Details: ${e.message}`);
     return `${OAUTH_CONFIG.authUrl}?${params.toString()}`;
   }
   async startCallbackServer(codeChallenge, state) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let redirectUri = "";
       const server = createServer((req, res) => {
         const url2 = new URL(req.url, redirectUri.replace("/callback", ""));
@@ -29106,7 +29665,7 @@ Details: ${e.message}`);
             </html>
           `);
           server.close();
-          resolve({ authCode: code, redirectUri });
+          resolve2({ authCode: code, redirectUri });
         } else {
           res.writeHead(404, { "Content-Type": "text/plain" });
           res.end("Not found");
@@ -29322,9 +29881,9 @@ __export(exports_kimi_oauth, {
   KimiOAuth: () => KimiOAuth
 });
 import { randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readFileSync3, existsSync as existsSync4, unlinkSync as unlinkSync2, openSync as openSync2, writeSync as writeSync2, closeSync as closeSync2 } from "fs";
-import { homedir as homedir3, hostname as hostname3, platform, release } from "os";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync5, unlinkSync as unlinkSync3, openSync as openSync2, writeSync as writeSync2, closeSync as closeSync2 } from "fs";
+import { homedir as homedir4, hostname as hostname3, platform, release } from "os";
+import { join as join5 } from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 
@@ -29349,23 +29908,23 @@ class KimiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join4(homedir3(), ".claudish");
-    return join4(claudishDir, "kimi-oauth.json");
+    const claudishDir = join5(homedir4(), ".claudish");
+    return join5(claudishDir, "kimi-oauth.json");
   }
   getDeviceIdPath() {
-    const claudishDir = join4(homedir3(), ".claudish");
-    return join4(claudishDir, "kimi-device-id");
+    const claudishDir = join5(homedir4(), ".claudish");
+    return join5(claudishDir, "kimi-device-id");
   }
   loadOrCreateDeviceId() {
     const deviceIdPath = this.getDeviceIdPath();
-    const claudishDir = join4(homedir3(), ".claudish");
-    if (!existsSync4(claudishDir)) {
-      const { mkdirSync: mkdirSync3 } = __require("fs");
-      mkdirSync3(claudishDir, { recursive: true });
+    const claudishDir = join5(homedir4(), ".claudish");
+    if (!existsSync5(claudishDir)) {
+      const { mkdirSync: mkdirSync4 } = __require("fs");
+      mkdirSync4(claudishDir, { recursive: true });
     }
-    if (existsSync4(deviceIdPath)) {
+    if (existsSync5(deviceIdPath)) {
       try {
-        const deviceId2 = readFileSync3(deviceIdPath, "utf-8").trim();
+        const deviceId2 = readFileSync4(deviceIdPath, "utf-8").trim();
         if (deviceId2) {
           return deviceId2;
         }
@@ -29389,7 +29948,7 @@ class KimiOAuth {
   }
   getVersion() {
     try {
-      const packageJson = JSON.parse(readFileSync3(join4(__dirname, "../../package.json"), "utf-8"));
+      const packageJson = JSON.parse(readFileSync4(join5(__dirname, "../../package.json"), "utf-8"));
       return packageJson.version;
     } catch {
       return "4.0.6";
@@ -29467,7 +30026,7 @@ Waiting for authorization...`);
     const timeoutMs = expiresIn * 1000;
     let currentInterval = interval * 1000;
     while (Date.now() - startTime < timeoutMs) {
-      await new Promise((resolve) => setTimeout(resolve, currentInterval));
+      await new Promise((resolve2) => setTimeout(resolve2, currentInterval));
       const result = await this.pollForTokenWithRetry(deviceCode);
       if (result.error) {
         if (result.error === "authorization_pending") {
@@ -29517,7 +30076,7 @@ Waiting for authorization...`);
     } catch (e) {
       if (retryCount < maxRetries) {
         log(`[KimiOAuth] Network error during polling (attempt ${retryCount + 1}/${maxRetries}), retrying in ${backoffMs}ms...`);
-        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+        await new Promise((resolve2) => setTimeout(resolve2, backoffMs));
         return this.pollForTokenWithRetry(deviceCode, retryCount + 1);
       }
       throw new Error(`Network error during token polling: ${e.message}`);
@@ -29539,8 +30098,8 @@ Waiting for authorization...`);
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync4(credPath)) {
-      unlinkSync2(credPath);
+    if (existsSync5(credPath)) {
+      unlinkSync3(credPath);
       log("[KimiOAuth] Credentials deleted");
     }
     this.credentials = null;
@@ -29606,8 +30165,8 @@ Waiting for authorization...`);
     } catch (e) {
       log(`[KimiOAuth] Refresh failed: ${e.message}`);
       const credPath = this.getCredentialsPath();
-      if (existsSync4(credPath)) {
-        unlinkSync2(credPath);
+      if (existsSync5(credPath)) {
+        unlinkSync3(credPath);
       }
       this.credentials = null;
       if (process.env.MOONSHOT_API_KEY || process.env.KIMI_API_KEY) {
@@ -29623,11 +30182,11 @@ Waiting for authorization...`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync4(credPath)) {
+    if (!existsSync5(credPath)) {
       return null;
     }
     try {
-      const data = readFileSync3(credPath, "utf-8");
+      const data = readFileSync4(credPath, "utf-8");
       const credentials = JSON.parse(data);
       if (!credentials.access_token || !credentials.refresh_token || !credentials.expires_at || !credentials.scope || !credentials.token_type) {
         log("[KimiOAuth] Invalid credentials file structure");
@@ -29642,10 +30201,10 @@ Waiting for authorization...`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join4(homedir3(), ".claudish");
-    if (!existsSync4(claudishDir)) {
-      const { mkdirSync: mkdirSync3 } = __require("fs");
-      mkdirSync3(claudishDir, { recursive: true });
+    const claudishDir = join5(homedir4(), ".claudish");
+    if (!existsSync5(claudishDir)) {
+      const { mkdirSync: mkdirSync4 } = __require("fs");
+      mkdirSync4(claudishDir, { recursive: true });
     }
     const fd = openSync2(credPath, "w", 384);
     try {
@@ -29666,10 +30225,10 @@ async function getValidKimiAccessToken() {
 }
 function hasKimiOAuthCredentials() {
   try {
-    const credPath = join4(homedir3(), ".claudish", "kimi-oauth.json");
-    if (!existsSync4(credPath))
+    const credPath = join5(homedir4(), ".claudish", "kimi-oauth.json");
+    if (!existsSync5(credPath))
       return false;
-    const data = JSON.parse(readFileSync3(credPath, "utf-8"));
+    const data = JSON.parse(readFileSync4(credPath, "utf-8"));
     const now = Date.now();
     const bufferMs = 5 * 60 * 1000;
     return !!(data.access_token && data.refresh_token && data.expires_at && data.expires_at > now + bufferMs);
@@ -29732,24 +30291,24 @@ var init_config = __esm(() => {
 });
 
 // src/model-loader.ts
-import { readFileSync as readFileSync4, existsSync as existsSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { join as join5, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync5, existsSync as existsSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join6, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { createHash as createHash2 } from "crypto";
 function getRecommendedModelsPath() {
-  return join5(__dirname3, "../recommended-models.json");
+  return join6(__dirname3, "../recommended-models.json");
 }
 function loadRecommendedModelsJSON() {
   if (_cachedRecommendedModels) {
     return _cachedRecommendedModels;
   }
   const jsonPath = getRecommendedModelsPath();
-  if (!existsSync5(jsonPath)) {
+  if (!existsSync6(jsonPath)) {
     throw new Error(`recommended-models.json not found at ${jsonPath}. ` + `Run 'claudish --update-models' to fetch the latest model list.`);
   }
   try {
-    const jsonContent = readFileSync4(jsonPath, "utf-8");
+    const jsonContent = readFileSync5(jsonPath, "utf-8");
     _cachedRecommendedModels = JSON.parse(jsonContent);
     return _cachedRecommendedModels;
   } catch (error46) {
@@ -29807,11 +30366,11 @@ async function ensureOpenRouterModelsLoaded() {
 }
 async function fetchLiteLLMModels(baseUrl, apiKey, forceUpdate = false) {
   const hash2 = createHash2("sha256").update(baseUrl).digest("hex").substring(0, 16);
-  const cacheDir = join5(homedir4(), ".claudish");
-  const cachePath = join5(cacheDir, `litellm-models-${hash2}.json`);
-  if (!forceUpdate && existsSync5(cachePath)) {
+  const cacheDir = join6(homedir5(), ".claudish");
+  const cachePath = join6(cacheDir, `litellm-models-${hash2}.json`);
+  if (!forceUpdate && existsSync6(cachePath)) {
     try {
-      const cacheData = JSON.parse(readFileSync4(cachePath, "utf-8"));
+      const cacheData = JSON.parse(readFileSync5(cachePath, "utf-8"));
       const timestamp = new Date(cacheData.timestamp);
       const now = new Date;
       const ageInHours = (now.getTime() - timestamp.getTime()) / (1000 * 60 * 60);
@@ -29830,9 +30389,9 @@ async function fetchLiteLLMModels(baseUrl, apiKey, forceUpdate = false) {
     });
     if (!response.ok) {
       console.error(`Failed to fetch LiteLLM models: ${response.status} ${response.statusText}`);
-      if (existsSync5(cachePath)) {
+      if (existsSync6(cachePath)) {
         try {
-          const cacheData2 = JSON.parse(readFileSync4(cachePath, "utf-8"));
+          const cacheData2 = JSON.parse(readFileSync5(cachePath, "utf-8"));
           return cacheData2.models;
         } catch {
           return [];
@@ -29868,18 +30427,18 @@ async function fetchLiteLLMModels(baseUrl, apiKey, forceUpdate = false) {
         source: "LiteLLM"
       };
     });
-    mkdirSync3(cacheDir, { recursive: true });
+    mkdirSync4(cacheDir, { recursive: true });
     const cacheData = {
       timestamp: new Date().toISOString(),
       models: transformedModels
     };
-    writeFileSync3(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
+    writeFileSync4(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
     return transformedModels;
   } catch (error46) {
     console.error(`Failed to fetch LiteLLM models: ${error46}`);
-    if (existsSync5(cachePath)) {
+    if (existsSync6(cachePath)) {
       try {
-        const cacheData = JSON.parse(readFileSync4(cachePath, "utf-8"));
+        const cacheData = JSON.parse(readFileSync5(cachePath, "utf-8"));
         return cacheData.models;
       } catch {
         return [];
@@ -29939,21 +30498,21 @@ function fuzzyScore2(text, query) {
 }
 
 // src/profile-config.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
 function ensureConfigDir() {
-  if (!existsSync6(CONFIG_DIR)) {
-    mkdirSync4(CONFIG_DIR, { recursive: true });
+  if (!existsSync7(CONFIG_DIR)) {
+    mkdirSync5(CONFIG_DIR, { recursive: true });
   }
 }
 function loadConfig() {
   ensureConfigDir();
-  if (!existsSync6(CONFIG_FILE)) {
+  if (!existsSync7(CONFIG_FILE)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
-    const content = readFileSync5(CONFIG_FILE, "utf-8");
+    const content = readFileSync6(CONFIG_FILE, "utf-8");
     const config3 = JSON.parse(content);
     const merged = {
       version: config3.version || DEFAULT_CONFIG.version,
@@ -29983,31 +30542,31 @@ function loadConfig() {
 }
 function saveConfig(config3) {
   ensureConfigDir();
-  writeFileSync4(CONFIG_FILE, JSON.stringify(config3, null, 2), "utf-8");
+  writeFileSync5(CONFIG_FILE, JSON.stringify(config3, null, 2), "utf-8");
 }
 function configExists() {
-  return existsSync6(CONFIG_FILE);
+  return existsSync7(CONFIG_FILE);
 }
 function getConfigPath() {
   return CONFIG_FILE;
 }
 function getLocalConfigPath() {
-  return join6(process.cwd(), LOCAL_CONFIG_FILENAME);
+  return join7(process.cwd(), LOCAL_CONFIG_FILENAME);
 }
 function localConfigExists() {
-  return existsSync6(getLocalConfigPath());
+  return existsSync7(getLocalConfigPath());
 }
 function isProjectDirectory() {
   const cwd = process.cwd();
-  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync6(join6(cwd, f)));
+  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync7(join7(cwd, f)));
 }
 function loadLocalConfig() {
   const localPath = getLocalConfigPath();
-  if (!existsSync6(localPath)) {
+  if (!existsSync7(localPath)) {
     return null;
   }
   try {
-    const content = readFileSync5(localPath, "utf-8");
+    const content = readFileSync6(localPath, "utf-8");
     const config3 = JSON.parse(content);
     const local = {
       version: config3.version || DEFAULT_CONFIG.version,
@@ -30024,7 +30583,7 @@ function loadLocalConfig() {
   }
 }
 function saveLocalConfig(config3) {
-  writeFileSync4(getLocalConfigPath(), JSON.stringify(config3, null, 2), "utf-8");
+  writeFileSync5(getLocalConfigPath(), JSON.stringify(config3, null, 2), "utf-8");
 }
 function loadConfigForScope(scope) {
   if (scope === "local") {
@@ -30229,8 +30788,8 @@ function removeEndpoint(name) {
 }
 var CONFIG_DIR, CONFIG_FILE, LOCAL_CONFIG_FILENAME = ".claudish.json", DEFAULT_CONFIG;
 var init_profile_config = __esm(() => {
-  CONFIG_DIR = join6(homedir5(), ".claudish");
-  CONFIG_FILE = join6(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join7(homedir6(), ".claudish");
+  CONFIG_FILE = join7(CONFIG_DIR, "config.json");
   DEFAULT_CONFIG = {
     version: "1.0.0",
     defaultProfile: "default",
@@ -30246,6 +30805,554 @@ var init_profile_config = __esm(() => {
   };
 });
 
+// src/providers/provider-definitions.ts
+function ensureProviderByNameCache() {
+  if (!_providerByNameCache) {
+    _providerByNameCache = new Map;
+    for (const def of BUILTIN_PROVIDERS) {
+      _providerByNameCache.set(def.name, def);
+    }
+  }
+  return _providerByNameCache;
+}
+function getShortcuts() {
+  if (!_shortcutsCache) {
+    _shortcutsCache = {};
+    for (const def of BUILTIN_PROVIDERS) {
+      for (const shortcut of def.shortcuts) {
+        _shortcutsCache[shortcut] = def.name;
+      }
+    }
+  }
+  return _shortcutsCache;
+}
+function getLegacyPrefixPatterns() {
+  if (!_legacyPrefixCache) {
+    _legacyPrefixCache = [];
+    for (const def of BUILTIN_PROVIDERS) {
+      for (const lp of def.legacyPrefixes) {
+        _legacyPrefixCache.push({
+          prefix: lp.prefix,
+          provider: def.name,
+          stripPrefix: lp.stripPrefix
+        });
+      }
+    }
+  }
+  return _legacyPrefixCache;
+}
+function getNativeModelPatterns() {
+  if (!_nativeModelPatternsCache) {
+    _nativeModelPatternsCache = [];
+    for (const def of BUILTIN_PROVIDERS) {
+      if (def.nativeModelPatterns) {
+        for (const np of def.nativeModelPatterns) {
+          _nativeModelPatternsCache.push({
+            pattern: np.pattern,
+            provider: def.name
+          });
+        }
+      }
+    }
+  }
+  return _nativeModelPatternsCache;
+}
+function getProviderByName(name) {
+  return ensureProviderByNameCache().get(name);
+}
+function getApiKeyInfo(providerName) {
+  const def = getProviderByName(providerName);
+  if (!def)
+    return null;
+  return {
+    envVar: def.apiKeyEnvVar,
+    description: def.apiKeyDescription,
+    url: def.apiKeyUrl,
+    aliases: def.apiKeyAliases,
+    oauthFallback: def.oauthFallback
+  };
+}
+function getDisplayName(providerName) {
+  const def = getProviderByName(providerName);
+  return def?.displayName || providerName.charAt(0).toUpperCase() + providerName.slice(1);
+}
+function getEffectiveBaseUrl(def) {
+  if (def.baseUrlEnvVars) {
+    for (const envVar of def.baseUrlEnvVars) {
+      const value = process.env[envVar];
+      if (value)
+        return value;
+    }
+  }
+  return def.baseUrl;
+}
+function isLocalTransport(providerName) {
+  if (!_localProvidersCache) {
+    _localProvidersCache = new Set;
+    for (const def of BUILTIN_PROVIDERS) {
+      if (def.isLocal) {
+        _localProvidersCache.add(def.name);
+      }
+    }
+  }
+  return _localProvidersCache.has(providerName.toLowerCase());
+}
+function toRemoteProvider(def) {
+  const baseUrl = getEffectiveBaseUrl(def);
+  let effectiveBaseUrl = baseUrl;
+  if (def.name === "opencode-zen-go" && def.baseUrlEnvVars) {
+    const envOverride = process.env[def.baseUrlEnvVars[0]];
+    if (envOverride) {
+      effectiveBaseUrl = envOverride.replace("/zen", "/zen/go");
+    }
+  }
+  return {
+    name: def.name === "google" ? "gemini" : def.name,
+    baseUrl: effectiveBaseUrl,
+    apiPath: def.apiPath,
+    apiKeyEnvVar: def.apiKeyEnvVar,
+    prefixes: def.legacyPrefixes.map((lp) => lp.prefix),
+    headers: def.headers,
+    authScheme: def.authScheme
+  };
+}
+function getAllProviders() {
+  return BUILTIN_PROVIDERS;
+}
+function getApiKeyEnvVars(providerName) {
+  const def = getProviderByName(providerName);
+  if (!def)
+    return null;
+  return {
+    envVar: def.apiKeyEnvVar,
+    aliases: def.apiKeyAliases
+  };
+}
+var BUILTIN_PROVIDERS, _shortcutsCache = null, _legacyPrefixCache = null, _nativeModelPatternsCache = null, _providerByNameCache = null, _localProvidersCache = null;
+var init_provider_definitions = __esm(() => {
+  BUILTIN_PROVIDERS = [
+    {
+      name: "google",
+      displayName: "Gemini",
+      transport: "gemini",
+      baseUrl: "https://generativelanguage.googleapis.com",
+      baseUrlEnvVars: ["GEMINI_BASE_URL"],
+      apiPath: "/v1beta/models/{model}:streamGenerateContent?alt=sse",
+      apiKeyEnvVar: "GEMINI_API_KEY",
+      apiKeyDescription: "Google Gemini API Key",
+      apiKeyUrl: "https://aistudio.google.com/app/apikey",
+      shortcuts: ["g", "gemini"],
+      shortestPrefix: "g",
+      legacyPrefixes: [
+        { prefix: "g/", stripPrefix: true },
+        { prefix: "gemini/", stripPrefix: true }
+      ],
+      nativeModelPatterns: [{ pattern: /^google\//i }, { pattern: /^gemini-/i }],
+      isDirectApi: true
+    },
+    {
+      name: "gemini-codeassist",
+      displayName: "Gemini Code Assist",
+      transport: "gemini-oauth",
+      baseUrl: "https://cloudcode-pa.googleapis.com",
+      apiPath: "/v1internal:streamGenerateContent?alt=sse",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Gemini Code Assist (OAuth)",
+      apiKeyUrl: "https://cloud.google.com/code-assist",
+      shortcuts: ["go"],
+      shortestPrefix: "go",
+      legacyPrefixes: [{ prefix: "go/", stripPrefix: true }],
+      isDirectApi: true
+    },
+    {
+      name: "openai",
+      displayName: "OpenAI",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://api.openai.com",
+      baseUrlEnvVars: ["OPENAI_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "OPENAI_API_KEY",
+      apiKeyDescription: "OpenAI API Key",
+      apiKeyUrl: "https://platform.openai.com/api-keys",
+      shortcuts: ["oai"],
+      shortestPrefix: "oai",
+      legacyPrefixes: [{ prefix: "oai/", stripPrefix: true }],
+      nativeModelPatterns: [
+        { pattern: /^openai\//i },
+        { pattern: /^gpt-/i },
+        { pattern: /^o1(-|$)/i },
+        { pattern: /^o3(-|$)/i },
+        { pattern: /^chatgpt-/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "openrouter",
+      displayName: "OpenRouter",
+      transport: "openrouter",
+      baseUrl: "https://openrouter.ai",
+      apiPath: "/api/v1/chat/completions",
+      apiKeyEnvVar: "OPENROUTER_API_KEY",
+      apiKeyDescription: "OpenRouter API Key",
+      apiKeyUrl: "https://openrouter.ai/keys",
+      shortcuts: ["or"],
+      shortestPrefix: "or",
+      legacyPrefixes: [{ prefix: "or/", stripPrefix: true }],
+      nativeModelPatterns: [{ pattern: /^openrouter\//i }],
+      headers: {
+        "HTTP-Referer": "https://claudish.com",
+        "X-Title": "Claudish - OpenRouter Proxy"
+      },
+      isDirectApi: true
+    },
+    {
+      name: "minimax",
+      displayName: "MiniMax",
+      transport: "anthropic",
+      baseUrl: "https://api.minimax.io",
+      baseUrlEnvVars: ["MINIMAX_BASE_URL"],
+      apiPath: "/anthropic/v1/messages",
+      apiKeyEnvVar: "MINIMAX_API_KEY",
+      apiKeyDescription: "MiniMax API Key",
+      apiKeyUrl: "https://www.minimaxi.com/",
+      authScheme: "bearer",
+      shortcuts: ["mm", "mmax"],
+      shortestPrefix: "mm",
+      legacyPrefixes: [
+        { prefix: "mmax/", stripPrefix: true },
+        { prefix: "mm/", stripPrefix: true }
+      ],
+      nativeModelPatterns: [
+        { pattern: /^minimax\//i },
+        { pattern: /^minimax-/i },
+        { pattern: /^abab-/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "minimax-coding",
+      displayName: "MiniMax Coding",
+      transport: "anthropic",
+      baseUrl: "https://api.minimax.io",
+      baseUrlEnvVars: ["MINIMAX_CODING_BASE_URL"],
+      apiPath: "/anthropic/v1/messages",
+      apiKeyEnvVar: "MINIMAX_CODING_API_KEY",
+      apiKeyDescription: "MiniMax Coding Plan API Key",
+      apiKeyUrl: "https://platform.minimax.io/user-center/basic-information/interface-key",
+      authScheme: "bearer",
+      shortcuts: ["mmc"],
+      shortestPrefix: "mmc",
+      legacyPrefixes: [{ prefix: "mmc/", stripPrefix: true }],
+      isDirectApi: true
+    },
+    {
+      name: "kimi-coding",
+      displayName: "Kimi Coding",
+      transport: "kimi-coding",
+      baseUrl: "https://api.kimi.com/coding/v1",
+      apiPath: "/messages",
+      apiKeyEnvVar: "KIMI_CODING_API_KEY",
+      apiKeyDescription: "Kimi Coding API Key",
+      apiKeyUrl: "https://kimi.com/code (get key from membership page, or run: claudish --kimi-login)",
+      oauthFallback: "kimi-oauth.json",
+      shortcuts: ["kc"],
+      shortestPrefix: "kc",
+      legacyPrefixes: [{ prefix: "kc/", stripPrefix: true }],
+      nativeModelPatterns: [{ pattern: /^kimi-for-coding$/i }],
+      isDirectApi: true
+    },
+    {
+      name: "kimi",
+      displayName: "Kimi",
+      transport: "anthropic",
+      baseUrl: "https://api.moonshot.ai",
+      baseUrlEnvVars: ["MOONSHOT_BASE_URL", "KIMI_BASE_URL"],
+      apiPath: "/anthropic/v1/messages",
+      apiKeyEnvVar: "MOONSHOT_API_KEY",
+      apiKeyAliases: ["KIMI_API_KEY"],
+      apiKeyDescription: "Kimi/Moonshot API Key",
+      apiKeyUrl: "https://platform.moonshot.cn/",
+      shortcuts: ["kimi", "moon", "moonshot"],
+      shortestPrefix: "kimi",
+      legacyPrefixes: [
+        { prefix: "kimi/", stripPrefix: true },
+        { prefix: "moonshot/", stripPrefix: true }
+      ],
+      nativeModelPatterns: [
+        { pattern: /^moonshot(ai)?\//i },
+        { pattern: /^moonshot-/i },
+        { pattern: /^kimi-/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "glm",
+      displayName: "GLM",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://open.bigmodel.cn",
+      baseUrlEnvVars: ["ZHIPU_BASE_URL", "GLM_BASE_URL"],
+      apiPath: "/api/paas/v4/chat/completions",
+      apiKeyEnvVar: "ZHIPU_API_KEY",
+      apiKeyAliases: ["GLM_API_KEY"],
+      apiKeyDescription: "GLM/Zhipu API Key",
+      apiKeyUrl: "https://open.bigmodel.cn/",
+      shortcuts: ["glm", "zhipu"],
+      shortestPrefix: "glm",
+      legacyPrefixes: [
+        { prefix: "glm/", stripPrefix: true },
+        { prefix: "zhipu/", stripPrefix: true }
+      ],
+      nativeModelPatterns: [
+        { pattern: /^zhipu\//i },
+        { pattern: /^glm-/i },
+        { pattern: /^chatglm-/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "glm-coding",
+      displayName: "GLM Coding",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://api.z.ai",
+      apiPath: "/api/coding/paas/v4/chat/completions",
+      apiKeyEnvVar: "GLM_CODING_API_KEY",
+      apiKeyAliases: ["ZAI_CODING_API_KEY"],
+      apiKeyDescription: "GLM Coding Plan API Key",
+      apiKeyUrl: "https://z.ai/subscribe",
+      shortcuts: ["gc"],
+      shortestPrefix: "gc",
+      legacyPrefixes: [{ prefix: "gc/", stripPrefix: true }],
+      isDirectApi: true
+    },
+    {
+      name: "zai",
+      displayName: "Z.AI",
+      transport: "anthropic",
+      baseUrl: "https://api.z.ai",
+      baseUrlEnvVars: ["ZAI_BASE_URL"],
+      apiPath: "/api/anthropic/v1/messages",
+      apiKeyEnvVar: "ZAI_API_KEY",
+      apiKeyDescription: "Z.AI API Key",
+      apiKeyUrl: "https://z.ai/",
+      shortcuts: ["zai"],
+      shortestPrefix: "zai",
+      legacyPrefixes: [{ prefix: "zai/", stripPrefix: true }],
+      nativeModelPatterns: [{ pattern: /^z-ai\//i }, { pattern: /^zai\//i }],
+      isDirectApi: true
+    },
+    {
+      name: "ollamacloud",
+      displayName: "OllamaCloud",
+      transport: "ollamacloud",
+      tokenStrategy: "accumulate-both",
+      baseUrl: "https://ollama.com",
+      baseUrlEnvVars: ["OLLAMACLOUD_BASE_URL"],
+      apiPath: "/api/chat",
+      apiKeyEnvVar: "OLLAMA_API_KEY",
+      apiKeyDescription: "OllamaCloud API Key",
+      apiKeyUrl: "https://ollama.com/account",
+      shortcuts: ["oc", "llama", "lc", "meta"],
+      shortestPrefix: "oc",
+      legacyPrefixes: [{ prefix: "oc/", stripPrefix: true }],
+      nativeModelPatterns: [
+        { pattern: /^ollamacloud\//i },
+        { pattern: /^meta-llama\//i },
+        { pattern: /^llama-/i },
+        { pattern: /^llama3/i }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "opencode-zen",
+      displayName: "OpenCode Zen",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://opencode.ai/zen",
+      baseUrlEnvVars: ["OPENCODE_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "OPENCODE_API_KEY",
+      apiKeyDescription: "OpenCode Zen (Free)",
+      apiKeyUrl: "https://opencode.ai/",
+      publicKeyFallback: "public",
+      shortcuts: ["zen"],
+      shortestPrefix: "zen",
+      legacyPrefixes: [{ prefix: "zen/", stripPrefix: true }],
+      isDirectApi: true
+    },
+    {
+      name: "opencode-zen-go",
+      displayName: "OpenCode Zen Go",
+      transport: "openai",
+      tokenStrategy: "delta-aware",
+      baseUrl: "https://opencode.ai/zen/go",
+      baseUrlEnvVars: ["OPENCODE_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "OPENCODE_API_KEY",
+      apiKeyDescription: "OpenCode Zen Go (Lite Plan)",
+      apiKeyUrl: "https://opencode.ai/",
+      shortcuts: ["zengo", "zgo"],
+      shortestPrefix: "zengo",
+      legacyPrefixes: [
+        { prefix: "zengo/", stripPrefix: true },
+        { prefix: "zgo/", stripPrefix: true }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "vertex",
+      displayName: "Vertex AI",
+      transport: "vertex",
+      baseUrl: "",
+      apiPath: "",
+      apiKeyEnvVar: "VERTEX_PROJECT",
+      apiKeyAliases: ["VERTEX_API_KEY"],
+      apiKeyDescription: "Vertex AI API Key",
+      apiKeyUrl: "https://console.cloud.google.com/vertex-ai",
+      shortcuts: ["v", "vertex"],
+      shortestPrefix: "v",
+      legacyPrefixes: [
+        { prefix: "v/", stripPrefix: true },
+        { prefix: "vertex/", stripPrefix: true }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "litellm",
+      displayName: "LiteLLM",
+      transport: "litellm",
+      baseUrl: "",
+      baseUrlEnvVars: ["LITELLM_BASE_URL"],
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "LITELLM_API_KEY",
+      apiKeyDescription: "LiteLLM API Key",
+      apiKeyUrl: "https://docs.litellm.ai/",
+      shortcuts: ["litellm", "ll"],
+      shortestPrefix: "ll",
+      legacyPrefixes: [
+        { prefix: "litellm/", stripPrefix: true },
+        { prefix: "ll/", stripPrefix: true }
+      ],
+      isDirectApi: true
+    },
+    {
+      name: "poe",
+      displayName: "Poe",
+      transport: "poe",
+      baseUrl: "https://api.poe.com",
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "POE_API_KEY",
+      apiKeyDescription: "Poe API Key",
+      apiKeyUrl: "https://poe.com/api_key",
+      shortcuts: ["poe"],
+      shortestPrefix: "poe",
+      legacyPrefixes: [],
+      nativeModelPatterns: [{ pattern: /^poe:/i }],
+      isDirectApi: true
+    },
+    {
+      name: "ollama",
+      displayName: "Ollama",
+      transport: "local",
+      baseUrl: "http://localhost:11434",
+      apiPath: "/api/chat",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Ollama (Local)",
+      apiKeyUrl: "",
+      shortcuts: ["ollama"],
+      shortestPrefix: "ollama",
+      legacyPrefixes: [
+        { prefix: "ollama/", stripPrefix: true },
+        { prefix: "ollama:", stripPrefix: true }
+      ],
+      isLocal: true
+    },
+    {
+      name: "lmstudio",
+      displayName: "LM Studio",
+      transport: "local",
+      baseUrl: "http://localhost:1234",
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "LM Studio (Local)",
+      apiKeyUrl: "",
+      shortcuts: ["lms", "lmstudio", "mlstudio"],
+      shortestPrefix: "lms",
+      legacyPrefixes: [
+        { prefix: "lmstudio/", stripPrefix: true },
+        { prefix: "lmstudio:", stripPrefix: true },
+        { prefix: "mlstudio/", stripPrefix: true },
+        { prefix: "mlstudio:", stripPrefix: true }
+      ],
+      isLocal: true
+    },
+    {
+      name: "vllm",
+      displayName: "vLLM",
+      transport: "local",
+      baseUrl: "http://localhost:8000",
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "vLLM (Local)",
+      apiKeyUrl: "",
+      shortcuts: ["vllm"],
+      shortestPrefix: "vllm",
+      legacyPrefixes: [
+        { prefix: "vllm/", stripPrefix: true },
+        { prefix: "vllm:", stripPrefix: true }
+      ],
+      isLocal: true
+    },
+    {
+      name: "mlx",
+      displayName: "MLX",
+      transport: "local",
+      baseUrl: "http://localhost:8080",
+      apiPath: "/v1/chat/completions",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "MLX (Local)",
+      apiKeyUrl: "",
+      shortcuts: ["mlx"],
+      shortestPrefix: "mlx",
+      legacyPrefixes: [
+        { prefix: "mlx/", stripPrefix: true },
+        { prefix: "mlx:", stripPrefix: true }
+      ],
+      isLocal: true
+    },
+    {
+      name: "qwen",
+      displayName: "Qwen",
+      transport: "openai",
+      baseUrl: "",
+      apiPath: "",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Qwen (auto-routed via OpenRouter)",
+      apiKeyUrl: "",
+      shortcuts: [],
+      shortestPrefix: "qwen",
+      legacyPrefixes: [],
+      nativeModelPatterns: [{ pattern: /^qwen/i }]
+    },
+    {
+      name: "native-anthropic",
+      displayName: "Anthropic (Native)",
+      transport: "anthropic",
+      baseUrl: "",
+      apiPath: "",
+      apiKeyEnvVar: "",
+      apiKeyDescription: "Anthropic (Native Claude Code auth)",
+      apiKeyUrl: "",
+      shortcuts: [],
+      shortestPrefix: "",
+      legacyPrefixes: [],
+      nativeModelPatterns: [{ pattern: /^anthropic\//i }, { pattern: /^claude-/i }]
+    }
+  ];
+});
+
 // src/providers/model-parser.ts
 function parseModelSpec(modelSpec) {
   const original = modelSpec;
@@ -30342,140 +31449,32 @@ function getLegacySyntaxWarning(parsed) {
   return `Deprecation warning: "${parsed.original}" uses legacy prefix syntax.
 ` + `  Consider using: ${newSyntax}`;
 }
-var PROVIDER_SHORTCUTS, DIRECT_API_PROVIDERS, LOCAL_PROVIDERS, NATIVE_MODEL_PATTERNS, LEGACY_PREFIX_PATTERNS;
+var PROVIDER_SHORTCUTS, LOCAL_PROVIDERS, NATIVE_MODEL_PATTERNS, LEGACY_PREFIX_PATTERNS;
 var init_model_parser = __esm(() => {
-  PROVIDER_SHORTCUTS = {
-    g: "google",
-    gemini: "google",
-    oai: "openai",
-    or: "openrouter",
-    mm: "minimax",
-    mmax: "minimax",
-    mmc: "minimax-coding",
-    kimi: "kimi",
-    moon: "kimi",
-    moonshot: "kimi",
-    kc: "kimi-coding",
-    glm: "glm",
-    zhipu: "glm",
-    gc: "glm-coding",
-    zai: "zai",
-    oc: "ollamacloud",
-    zen: "opencode-zen",
-    zengo: "opencode-zen-go",
-    zgo: "opencode-zen-go",
-    v: "vertex",
-    vertex: "vertex",
-    go: "gemini-codeassist",
-    llama: "ollamacloud",
-    lc: "ollamacloud",
-    meta: "ollamacloud",
-    poe: "poe",
-    litellm: "litellm",
-    ll: "litellm",
-    ollama: "ollama",
-    lms: "lmstudio",
-    lmstudio: "lmstudio",
-    mlstudio: "lmstudio",
-    vllm: "vllm",
-    mlx: "mlx"
-  };
-  DIRECT_API_PROVIDERS = new Set([
-    "google",
-    "openai",
-    "minimax",
-    "kimi",
-    "minimax-coding",
-    "kimi-coding",
-    "glm",
-    "glm-coding",
-    "zai",
-    "ollamacloud",
-    "opencode-zen",
-    "vertex",
-    "gemini-codeassist",
-    "poe",
-    "litellm"
-  ]);
-  LOCAL_PROVIDERS = new Set(["ollama", "lmstudio", "vllm", "mlx"]);
-  NATIVE_MODEL_PATTERNS = [
-    { pattern: /^google\//i, provider: "google" },
-    { pattern: /^gemini-/i, provider: "google" },
-    { pattern: /^openai\//i, provider: "openai" },
-    { pattern: /^gpt-/i, provider: "openai" },
-    { pattern: /^o1(-|$)/i, provider: "openai" },
-    { pattern: /^o3(-|$)/i, provider: "openai" },
-    { pattern: /^chatgpt-/i, provider: "openai" },
-    { pattern: /^minimax\//i, provider: "minimax" },
-    { pattern: /^minimax-/i, provider: "minimax" },
-    { pattern: /^abab-/i, provider: "minimax" },
-    { pattern: /^kimi-for-coding$/i, provider: "kimi-coding" },
-    { pattern: /^moonshot(ai)?\//i, provider: "kimi" },
-    { pattern: /^moonshot-/i, provider: "kimi" },
-    { pattern: /^kimi-/i, provider: "kimi" },
-    { pattern: /^zhipu\//i, provider: "glm" },
-    { pattern: /^glm-/i, provider: "glm" },
-    { pattern: /^chatglm-/i, provider: "glm" },
-    { pattern: /^z-ai\//i, provider: "zai" },
-    { pattern: /^zai\//i, provider: "zai" },
-    { pattern: /^ollamacloud\//i, provider: "ollamacloud" },
-    { pattern: /^meta-llama\//i, provider: "ollamacloud" },
-    { pattern: /^llama-/i, provider: "ollamacloud" },
-    { pattern: /^llama3/i, provider: "ollamacloud" },
-    { pattern: /^openrouter\//i, provider: "openrouter" },
-    { pattern: /^qwen/i, provider: "qwen" },
-    { pattern: /^poe:/i, provider: "poe" },
-    { pattern: /^anthropic\//i, provider: "native-anthropic" },
-    { pattern: /^claude-/i, provider: "native-anthropic" }
-  ];
-  LEGACY_PREFIX_PATTERNS = [
-    { prefix: "g/", provider: "google", stripPrefix: true },
-    { prefix: "gemini/", provider: "google", stripPrefix: true },
-    { prefix: "oai/", provider: "openai", stripPrefix: true },
-    { prefix: "or/", provider: "openrouter", stripPrefix: true },
-    { prefix: "mmax/", provider: "minimax", stripPrefix: true },
-    { prefix: "mm/", provider: "minimax", stripPrefix: true },
-    { prefix: "mmc/", provider: "minimax-coding", stripPrefix: true },
-    { prefix: "kimi/", provider: "kimi", stripPrefix: true },
-    { prefix: "moonshot/", provider: "kimi", stripPrefix: true },
-    { prefix: "kc/", provider: "kimi-coding", stripPrefix: true },
-    { prefix: "glm/", provider: "glm", stripPrefix: true },
-    { prefix: "zhipu/", provider: "glm", stripPrefix: true },
-    { prefix: "gc/", provider: "glm-coding", stripPrefix: true },
-    { prefix: "zai/", provider: "zai", stripPrefix: true },
-    { prefix: "oc/", provider: "ollamacloud", stripPrefix: true },
-    { prefix: "zen/", provider: "opencode-zen", stripPrefix: true },
-    { prefix: "zengo/", provider: "opencode-zen-go", stripPrefix: true },
-    { prefix: "zgo/", provider: "opencode-zen-go", stripPrefix: true },
-    { prefix: "v/", provider: "vertex", stripPrefix: true },
-    { prefix: "vertex/", provider: "vertex", stripPrefix: true },
-    { prefix: "go/", provider: "gemini-codeassist", stripPrefix: true },
-    { prefix: "ollama/", provider: "ollama", stripPrefix: true },
-    { prefix: "ollama:", provider: "ollama", stripPrefix: true },
-    { prefix: "lmstudio/", provider: "lmstudio", stripPrefix: true },
-    { prefix: "lmstudio:", provider: "lmstudio", stripPrefix: true },
-    { prefix: "mlstudio/", provider: "lmstudio", stripPrefix: true },
-    { prefix: "mlstudio:", provider: "lmstudio", stripPrefix: true },
-    { prefix: "vllm/", provider: "vllm", stripPrefix: true },
-    { prefix: "vllm:", provider: "vllm", stripPrefix: true },
-    { prefix: "mlx/", provider: "mlx", stripPrefix: true },
-    { prefix: "mlx:", provider: "mlx", stripPrefix: true }
-  ];
+  init_provider_definitions();
+  PROVIDER_SHORTCUTS = getShortcuts();
+  LOCAL_PROVIDERS = {
+    has(name) {
+      return isLocalTransport(name);
+    }
+  };
+  NATIVE_MODEL_PATTERNS = getNativeModelPatterns();
+  LEGACY_PREFIX_PATTERNS = getLegacyPrefixPatterns();
 });
 
 // src/auth/oauth-registry.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
 function hasValidOAuthCredentials(descriptor) {
-  const credPath = join7(homedir6(), ".claudish", descriptor.credentialFile);
-  if (!existsSync7(credPath))
+  const credPath = join8(homedir7(), ".claudish", descriptor.credentialFile);
+  if (!existsSync8(credPath))
     return false;
   if (descriptor.validationMode === "file-exists") {
     return true;
   }
   try {
-    const data = JSON.parse(readFileSync6(credPath, "utf-8"));
+    const data = JSON.parse(readFileSync7(credPath, "utf-8"));
     if (!data.access_token)
       return false;
     if (data.refresh_token)
@@ -30555,9 +31554,9 @@ var init_static_fallback = __esm(() => {
 });
 
 // src/providers/catalog-resolvers/openrouter.ts
-import { readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
-import { homedir as homedir7 } from "os";
+import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
+import { join as join9 } from "path";
+import { homedir as homedir8 } from "os";
 
 class OpenRouterCatalogResolver {
   provider = "openrouter";
@@ -30602,10 +31601,10 @@ class OpenRouterCatalogResolver {
   _getModels() {
     if (_memCache)
       return _memCache;
-    const diskPath = join8(homedir7(), ".claudish", "all-models.json");
-    if (existsSync8(diskPath)) {
+    const diskPath = join9(homedir8(), ".claudish", "all-models.json");
+    if (existsSync9(diskPath)) {
       try {
-        const data = JSON.parse(readFileSync7(diskPath, "utf-8"));
+        const data = JSON.parse(readFileSync8(diskPath, "utf-8"));
         if (Array.isArray(data.models) && data.models.length > 0) {
           _memCache = data.models;
           return _memCache;
@@ -30622,16 +31621,16 @@ var init_openrouter = __esm(() => {
 });
 
 // src/providers/catalog-resolvers/litellm.ts
-import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir8 } from "os";
+import { readFileSync as readFileSync9, existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir9 } from "os";
 import { createHash as createHash3 } from "crypto";
 function getCachePath() {
   const baseUrl = process.env.LITELLM_BASE_URL;
   if (!baseUrl)
     return null;
   const hash2 = createHash3("sha256").update(baseUrl).digest("hex").substring(0, 16);
-  return join9(homedir8(), ".claudish", `litellm-models-${hash2}.json`);
+  return join10(homedir9(), ".claudish", `litellm-models-${hash2}.json`);
 }
 
 class LiteLLMCatalogResolver {
@@ -30659,10 +31658,10 @@ class LiteLLMCatalogResolver {
   }
   async warmCache() {
     const path = getCachePath();
-    if (!path || !existsSync9(path))
+    if (!path || !existsSync10(path))
       return;
     try {
-      const data = JSON.parse(readFileSync8(path, "utf-8"));
+      const data = JSON.parse(readFileSync9(path, "utf-8"));
       if (Array.isArray(data.models)) {
         _memCache2 = data.models.map((m) => m.name ?? m.id?.replace("litellm@", "") ?? "");
       }
@@ -30675,10 +31674,10 @@ class LiteLLMCatalogResolver {
     if (_memCache2)
       return _memCache2;
     const path = getCachePath();
-    if (!path || !existsSync9(path))
+    if (!path || !existsSync10(path))
       return null;
     try {
-      const data = JSON.parse(readFileSync8(path, "utf-8"));
+      const data = JSON.parse(readFileSync9(path, "utf-8"));
       if (Array.isArray(data.models)) {
         _memCache2 = data.models.map((m) => m.name ?? m.id?.replace("litellm@", "") ?? "");
         return _memCache2;
@@ -30737,17 +31736,17 @@ var init_model_catalog_resolver = __esm(() => {
 });
 
 // src/providers/auto-route.ts
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
-import { join as join10 } from "path";
-import { homedir as homedir9 } from "os";
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir10 } from "os";
 import { createHash as createHash4 } from "crypto";
 function readLiteLLMCacheSync(baseUrl) {
   const hash2 = createHash4("sha256").update(baseUrl).digest("hex").substring(0, 16);
-  const cachePath = join10(homedir9(), ".claudish", `litellm-models-${hash2}.json`);
-  if (!existsSync10(cachePath))
+  const cachePath = join11(homedir10(), ".claudish", `litellm-models-${hash2}.json`);
+  if (!existsSync11(cachePath))
     return null;
   try {
-    const data = JSON.parse(readFileSync9(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync10(cachePath, "utf-8"));
     if (!Array.isArray(data.models))
       return null;
     return data.models;
@@ -30767,7 +31766,7 @@ function checkOAuthForProvider(nativeProvider, modelName) {
   };
 }
 function checkApiKeyForProvider(nativeProvider, modelName) {
-  const keyInfo = API_KEY_ENV_VARS[nativeProvider];
+  const keyInfo = getApiKeyEnvVars(nativeProvider);
   if (!keyInfo)
     return null;
   if (keyInfo.envVar && process.env[keyInfo.envVar]) {
@@ -30858,11 +31857,11 @@ function autoRoute(modelName, nativeProvider) {
   return null;
 }
 function readZenModelCacheSync() {
-  const cachePath = join10(homedir9(), ".claudish", "zen-models.json");
-  if (!existsSync10(cachePath))
+  const cachePath = join11(homedir10(), ".claudish", "zen-models.json");
+  if (!existsSync11(cachePath))
     return null;
   try {
-    const data = JSON.parse(readFileSync9(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync10(cachePath, "utf-8"));
     if (!Array.isArray(data.models))
       return null;
     return new Set(data.models.map((m) => m.id));
@@ -30889,13 +31888,13 @@ async function warmZenModelCache() {
   const models = (data.data ?? []).map((m) => ({ id: m.id }));
   if (models.length === 0)
     return;
-  const cacheDir = join10(homedir9(), ".claudish");
-  const { mkdirSync: mkdirSync5, writeFileSync: writeSync3 } = await import("fs");
-  mkdirSync5(cacheDir, { recursive: true });
-  writeSync3(join10(cacheDir, "zen-models.json"), JSON.stringify({ models, fetchedAt: new Date().toISOString() }));
+  const cacheDir = join11(homedir10(), ".claudish");
+  const { mkdirSync: mkdirSync6, writeFileSync: writeSync3 } = await import("fs");
+  mkdirSync6(cacheDir, { recursive: true });
+  writeSync3(join11(cacheDir, "zen-models.json"), JSON.stringify({ models, fetchedAt: new Date().toISOString() }));
 }
 function hasProviderCredentials(provider) {
-  const keyInfo = API_KEY_ENV_VARS[provider];
+  const keyInfo = getApiKeyEnvVars(provider);
   if (keyInfo?.envVar && process.env[keyInfo.envVar])
     return true;
   if (keyInfo?.aliases?.some((a) => process.env[a]))
@@ -30948,27 +31947,12 @@ function getFallbackChain(modelName, nativeProvider) {
   }
   return routes;
 }
-var API_KEY_ENV_VARS, PROVIDER_HINT_MAP, PROVIDER_TO_PREFIX, DISPLAY_NAMES, SUBSCRIPTION_ALTERNATIVES;
+var PROVIDER_HINT_MAP, PROVIDER_TO_PREFIX, DISPLAY_NAMES, SUBSCRIPTION_ALTERNATIVES;
 var init_auto_route = __esm(() => {
   init_oauth_registry();
   init_model_catalog_resolver();
-  API_KEY_ENV_VARS = {
-    google: { envVar: "GEMINI_API_KEY" },
-    "gemini-codeassist": { envVar: "GEMINI_API_KEY" },
-    openai: { envVar: "OPENAI_API_KEY" },
-    minimax: { envVar: "MINIMAX_API_KEY" },
-    "minimax-coding": { envVar: "MINIMAX_CODING_API_KEY" },
-    kimi: { envVar: "MOONSHOT_API_KEY", aliases: ["KIMI_API_KEY"] },
-    "kimi-coding": { envVar: "KIMI_CODING_API_KEY" },
-    glm: { envVar: "ZHIPU_API_KEY", aliases: ["GLM_API_KEY"] },
-    "glm-coding": { envVar: "GLM_CODING_API_KEY", aliases: ["ZAI_CODING_API_KEY"] },
-    zai: { envVar: "ZAI_API_KEY" },
-    ollamacloud: { envVar: "OLLAMA_API_KEY" },
-    litellm: { envVar: "LITELLM_API_KEY" },
-    openrouter: { envVar: "OPENROUTER_API_KEY" },
-    vertex: { envVar: "VERTEX_API_KEY", aliases: ["VERTEX_PROJECT"] },
-    poe: { envVar: "POE_API_KEY" }
-  };
+  init_provider_definitions();
+  init_provider_definitions();
   PROVIDER_HINT_MAP = {
     "kimi-coding": {
       loginFlag: "--kimi-login",
@@ -31012,39 +31996,22 @@ var init_auto_route = __esm(() => {
       apiKeyEnvVar: "OLLAMA_API_KEY"
     }
   };
-  PROVIDER_TO_PREFIX = {
-    google: "g",
-    openai: "oai",
-    minimax: "mm",
-    "minimax-coding": "mmc",
-    kimi: "kimi",
-    "kimi-coding": "kc",
-    glm: "glm",
-    "glm-coding": "gc",
-    zai: "zai",
-    ollamacloud: "oc",
-    "opencode-zen": "zen",
-    "opencode-zen-go": "zengo",
-    litellm: "ll",
-    vertex: "v",
-    "gemini-codeassist": "go"
-  };
-  DISPLAY_NAMES = {
-    google: "Gemini",
-    openai: "OpenAI",
-    minimax: "MiniMax",
-    "minimax-coding": "MiniMax Coding",
-    kimi: "Kimi",
-    "kimi-coding": "Kimi Coding",
-    glm: "GLM",
-    "glm-coding": "GLM Coding",
-    zai: "Z.AI",
-    ollamacloud: "OllamaCloud",
-    "opencode-zen": "OpenCode Zen",
-    "opencode-zen-go": "OpenCode Zen Go",
-    litellm: "LiteLLM",
-    openrouter: "OpenRouter"
-  };
+  PROVIDER_TO_PREFIX = (() => {
+    const map3 = {};
+    for (const def of getAllProviders()) {
+      if (def.shortestPrefix) {
+        map3[def.name] = def.shortestPrefix;
+      }
+    }
+    return map3;
+  })();
+  DISPLAY_NAMES = (() => {
+    const map3 = {};
+    for (const def of getAllProviders()) {
+      map3[def.name] = def.displayName;
+    }
+    return map3;
+  })();
   SUBSCRIPTION_ALTERNATIVES = {
     kimi: {
       subscriptionProvider: "kimi-coding",
@@ -31275,40 +32242,20 @@ function resolveRemoteProvider(modelId) {
   if (parsed.provider === "custom-url") {
     return null;
   }
-  const providerNameMap = {
-    google: "gemini",
-    openai: "openai",
-    openrouter: "openrouter",
-    minimax: "minimax",
-    "minimax-coding": "minimax-coding",
-    kimi: "kimi",
-    "kimi-coding": "kimi-coding",
-    glm: "glm",
-    "glm-coding": "glm-coding",
-    zai: "zai",
-    ollamacloud: "ollamacloud",
-    "opencode-zen": "opencode-zen",
-    "opencode-zen-go": "opencode-zen-go",
-    vertex: "vertex",
-    "gemini-codeassist": "gemini-codeassist",
-    litellm: "litellm"
-  };
-  const mappedProviderName = providerNameMap[parsed.provider];
-  if (mappedProviderName) {
-    const provider = providers.find((p) => p.name === mappedProviderName);
-    if (provider) {
-      return {
-        provider,
-        modelName: parsed.model,
-        isLegacySyntax: parsed.isLegacySyntax
-      };
-    }
+  const mappedName = parsed.provider === "google" ? "gemini" : parsed.provider;
+  const provider = providers.find((p) => p.name === mappedName || p.name === parsed.provider);
+  if (provider) {
+    return {
+      provider,
+      modelName: parsed.model,
+      isLegacySyntax: parsed.isLegacySyntax
+    };
   }
-  for (const provider of providers) {
-    for (const prefix of provider.prefixes) {
+  for (const provider2 of providers) {
+    for (const prefix of provider2.prefixes) {
       if (modelId.startsWith(prefix)) {
         return {
-          provider,
+          provider: provider2,
           modelName: modelId.slice(prefix.length),
           isLegacySyntax: true
         };
@@ -31354,128 +32301,12 @@ Set it with:
 function getRegisteredRemoteProviders() {
   return getRemoteProviders();
 }
-var getRemoteProviders = () => [
-  {
-    name: "gemini",
-    baseUrl: process.env.GEMINI_BASE_URL || "https://generativelanguage.googleapis.com",
-    apiPath: "/v1beta/models/{model}:streamGenerateContent?alt=sse",
-    apiKeyEnvVar: "GEMINI_API_KEY",
-    prefixes: ["g/", "gemini/"]
-  },
-  {
-    name: "gemini-codeassist",
-    baseUrl: "https://cloudcode-pa.googleapis.com",
-    apiPath: "/v1internal:streamGenerateContent?alt=sse",
-    apiKeyEnvVar: "",
-    prefixes: ["go/"]
-  },
-  {
-    name: "openai",
-    baseUrl: process.env.OPENAI_BASE_URL || "https://api.openai.com",
-    apiPath: "/v1/chat/completions",
-    apiKeyEnvVar: "OPENAI_API_KEY",
-    prefixes: ["oai/"]
-  },
-  {
-    name: "openrouter",
-    baseUrl: "https://openrouter.ai",
-    apiPath: "/api/v1/chat/completions",
-    apiKeyEnvVar: "OPENROUTER_API_KEY",
-    prefixes: ["or/"],
-    headers: {
-      "HTTP-Referer": "https://claudish.com",
-      "X-Title": "Claudish - OpenRouter Proxy"
-    }
-  },
-  {
-    name: "minimax",
-    baseUrl: process.env.MINIMAX_BASE_URL || "https://api.minimax.io",
-    apiPath: "/anthropic/v1/messages",
-    apiKeyEnvVar: "MINIMAX_API_KEY",
-    prefixes: ["mmax/", "mm/"],
-    authScheme: "bearer"
-  },
-  {
-    name: "minimax-coding",
-    baseUrl: process.env.MINIMAX_CODING_BASE_URL || "https://api.minimax.io",
-    apiPath: "/anthropic/v1/messages",
-    apiKeyEnvVar: "MINIMAX_CODING_API_KEY",
-    prefixes: ["mmc/"],
-    authScheme: "bearer"
-  },
-  {
-    name: "kimi",
-    baseUrl: process.env.MOONSHOT_BASE_URL || process.env.KIMI_BASE_URL || "https://api.moonshot.ai",
-    apiPath: "/anthropic/v1/messages",
-    apiKeyEnvVar: "MOONSHOT_API_KEY",
-    prefixes: ["kimi/", "moonshot/"]
-  },
-  {
-    name: "kimi-coding",
-    baseUrl: "https://api.kimi.com/coding/v1",
-    apiPath: "/messages",
-    apiKeyEnvVar: "KIMI_CODING_API_KEY",
-    prefixes: ["kc/"]
-  },
-  {
-    name: "glm",
-    baseUrl: process.env.ZHIPU_BASE_URL || process.env.GLM_BASE_URL || "https://open.bigmodel.cn",
-    apiPath: "/api/paas/v4/chat/completions",
-    apiKeyEnvVar: "ZHIPU_API_KEY",
-    prefixes: ["glm/", "zhipu/"]
-  },
-  {
-    name: "glm-coding",
-    baseUrl: "https://api.z.ai",
-    apiPath: "/api/coding/paas/v4/chat/completions",
-    apiKeyEnvVar: "GLM_CODING_API_KEY",
-    prefixes: ["gc/"]
-  },
-  {
-    name: "zai",
-    baseUrl: process.env.ZAI_BASE_URL || "https://api.z.ai",
-    apiPath: "/api/anthropic/v1/messages",
-    apiKeyEnvVar: "ZAI_API_KEY",
-    prefixes: ["zai/"]
-  },
-  {
-    name: "ollamacloud",
-    baseUrl: process.env.OLLAMACLOUD_BASE_URL || "https://ollama.com",
-    apiPath: "/api/chat",
-    apiKeyEnvVar: "OLLAMA_API_KEY",
-    prefixes: ["oc/"]
-  },
-  {
-    name: "opencode-zen",
-    baseUrl: process.env.OPENCODE_BASE_URL || "https://opencode.ai/zen",
-    apiPath: "/v1/chat/completions",
-    apiKeyEnvVar: "OPENCODE_API_KEY",
-    prefixes: ["zen/"]
-  },
-  {
-    name: "opencode-zen-go",
-    baseUrl: process.env.OPENCODE_BASE_URL ? process.env.OPENCODE_BASE_URL.replace("/zen", "/zen/go") : "https://opencode.ai/zen/go",
-    apiPath: "/v1/chat/completions",
-    apiKeyEnvVar: "OPENCODE_API_KEY",
-    prefixes: ["zengo/", "zgo/"]
-  },
-  {
-    name: "vertex",
-    baseUrl: "",
-    apiPath: "",
-    apiKeyEnvVar: "VERTEX_PROJECT",
-    prefixes: ["v/", "vertex/"]
-  },
-  {
-    name: "litellm",
-    baseUrl: process.env.LITELLM_BASE_URL || "",
-    apiPath: "/v1/chat/completions",
-    apiKeyEnvVar: "LITELLM_API_KEY",
-    prefixes: ["litellm/", "ll/"]
-  }
-];
+var getRemoteProviders = () => {
+  return getAllProviders().filter((def) => !def.isLocal && def.baseUrl !== "" && def.name !== "qwen" && def.name !== "native-anthropic").map(toRemoteProvider);
+};
 var init_remote_provider_registry = __esm(() => {
   init_model_parser();
+  init_provider_definitions();
 });
 
 // src/providers/provider-resolver.ts
@@ -31489,9 +32320,27 @@ __export(exports_provider_resolver, {
   getMissingKeyResolutions: () => getMissingKeyResolutions,
   getMissingKeyError: () => getMissingKeyError
 });
-import { existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir10 } from "os";
+import { existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir11 } from "os";
+function getApiKeyInfoForProvider(providerName) {
+  const lookupName = providerName === "gemini" ? "google" : providerName;
+  const info = getApiKeyInfo(lookupName);
+  if (info) {
+    return {
+      envVar: info.envVar,
+      description: info.description,
+      url: info.url,
+      aliases: info.aliases,
+      oauthFallback: info.oauthFallback
+    };
+  }
+  return {
+    envVar: "",
+    description: `${providerName} API Key`,
+    url: ""
+  };
+}
 function isApiKeyAvailable(info) {
   if (!info.envVar) {
     return true;
@@ -31508,8 +32357,8 @@ function isApiKeyAvailable(info) {
   }
   if (info.oauthFallback) {
     try {
-      const credPath = join11(homedir10(), ".claudish", info.oauthFallback);
-      if (existsSync11(credPath)) {
+      const credPath = join12(homedir11(), ".claudish", info.oauthFallback);
+      if (existsSync12(credPath)) {
         return true;
       }
     } catch {}
@@ -31792,105 +32641,21 @@ var init_provider_resolver = __esm(() => {
   init_remote_provider_registry();
   init_auto_route();
   init_model_parser();
-  API_KEY_INFO = {
-    openrouter: {
-      envVar: "OPENROUTER_API_KEY",
-      description: "OpenRouter API Key",
-      url: "https://openrouter.ai/keys"
-    },
-    gemini: {
-      envVar: "GEMINI_API_KEY",
-      description: "Google Gemini API Key",
-      url: "https://aistudio.google.com/app/apikey"
-    },
-    "gemini-codeassist": {
-      envVar: "",
-      description: "Gemini Code Assist (OAuth)",
-      url: "https://cloud.google.com/code-assist"
-    },
-    vertex: {
-      envVar: "VERTEX_API_KEY",
-      description: "Vertex AI API Key",
-      url: "https://console.cloud.google.com/vertex-ai",
-      aliases: ["VERTEX_PROJECT"]
-    },
-    openai: {
-      envVar: "OPENAI_API_KEY",
-      description: "OpenAI API Key",
-      url: "https://platform.openai.com/api-keys"
-    },
-    minimax: {
-      envVar: "MINIMAX_API_KEY",
-      description: "MiniMax API Key",
-      url: "https://www.minimaxi.com/"
-    },
-    "minimax-coding": {
-      envVar: "MINIMAX_CODING_API_KEY",
-      description: "MiniMax Coding Plan API Key",
-      url: "https://platform.minimax.io/user-center/basic-information/interface-key"
-    },
-    kimi: {
-      envVar: "MOONSHOT_API_KEY",
-      description: "Kimi/Moonshot API Key",
-      url: "https://platform.moonshot.cn/",
-      aliases: ["KIMI_API_KEY"]
-    },
-    "kimi-coding": {
-      envVar: "KIMI_CODING_API_KEY",
-      description: "Kimi Coding API Key",
-      url: "https://kimi.com/code (get key from membership page, or run: claudish --kimi-login)",
-      oauthFallback: "kimi-oauth.json"
+  init_provider_definitions();
+  API_KEY_INFO = new Proxy({}, {
+    get(_target, prop) {
+      return getApiKeyInfoForProvider(prop);
     },
-    glm: {
-      envVar: "ZHIPU_API_KEY",
-      description: "GLM/Zhipu API Key",
-      url: "https://open.bigmodel.cn/",
-      aliases: ["GLM_API_KEY"]
-    },
-    "glm-coding": {
-      envVar: "GLM_CODING_API_KEY",
-      description: "GLM Coding Plan API Key",
-      url: "https://z.ai/subscribe",
-      aliases: ["ZAI_CODING_API_KEY"]
-    },
-    ollamacloud: {
-      envVar: "OLLAMA_API_KEY",
-      description: "OllamaCloud API Key",
-      url: "https://ollama.com/account"
-    },
-    "opencode-zen": {
-      envVar: "",
-      description: "OpenCode Zen (Free)",
-      url: "https://opencode.ai/"
-    },
-    zai: {
-      envVar: "ZAI_API_KEY",
-      description: "Z.AI API Key",
-      url: "https://z.ai/"
-    },
-    litellm: {
-      envVar: "LITELLM_API_KEY",
-      description: "LiteLLM API Key",
-      url: "https://docs.litellm.ai/"
+    has() {
+      return true;
     }
-  };
-  PROVIDER_DISPLAY_NAMES = {
-    gemini: "Gemini",
-    "gemini-codeassist": "Gemini Code Assist",
-    vertex: "Vertex AI",
-    openai: "OpenAI",
-    openrouter: "OpenRouter",
-    minimax: "MiniMax",
-    "minimax-coding": "MiniMax Coding",
-    kimi: "Kimi",
-    "kimi-coding": "Kimi Coding",
-    glm: "GLM",
-    "glm-coding": "GLM Coding",
-    zai: "Z.AI",
-    ollamacloud: "OllamaCloud",
-    "opencode-zen": "OpenCode Zen",
-    litellm: "LiteLLM"
-  };
+  });
+  PROVIDER_DISPLAY_NAMES = new Proxy({}, {
+    get(_target, prop) {
+      const lookupName = prop === "gemini" ? "google" : prop;
+      return getDisplayName(lookupName);
+    }
+  });
 });
 
 // src/adapters/tool-name-utils.ts
@@ -32219,6 +32984,12 @@ var init_openai_tools = __esm(() => {
 });
 
 // src/adapters/base-adapter.ts
+function matchesModelFamily(modelId, family) {
+  const lower = modelId.toLowerCase();
+  const fam = family.toLowerCase();
+  return lower.startsWith(fam) || lower.includes(`/${fam}`);
+}
+
 class BaseModelAdapter {
   modelId;
   toolNameMap = new Map;
@@ -32414,13 +33185,15 @@ var init_grok_adapter = __esm(() => {
       return params;
     }
     shouldHandle(modelId) {
-      return modelId.includes("grok") || modelId.includes("x-ai/");
+      return matchesModelFamily(modelId, "grok") || modelId.toLowerCase().includes("x-ai/");
     }
     getName() {
       return "GrokAdapter";
     }
     getContextWindow() {
       const model = this.modelId.toLowerCase();
+      if (model.includes("grok-4.20") || model.includes("grok-4-20"))
+        return 2000000;
       if (model.includes("grok-4.1-fast") || model.includes("grok-4-1-fast"))
         return 2000000;
       if (model.includes("grok-4-fast"))
@@ -33666,10 +34439,10 @@ CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
       this.reasoningBlockDepth = 0;
     }
     getContextWindow() {
-      return 1e6;
+      return 1048576;
     }
     shouldHandle(modelId) {
-      return modelId.includes("gemini") || modelId.includes("google/");
+      return matchesModelFamily(modelId, "gemini") || modelId.toLowerCase().includes("google/");
     }
     getName() {
       return "GeminiAdapter";
@@ -33722,7 +34495,7 @@ var init_codex_adapter = __esm(() => {
       };
     }
     shouldHandle(modelId) {
-      return modelId.toLowerCase().includes("codex");
+      return matchesModelFamily(modelId, "codex");
     }
     getName() {
       return "CodexAdapter";
@@ -33886,9 +34659,11 @@ var init_openai_adapter = __esm(() => {
     }
     getContextWindow() {
       const model = this.modelId.toLowerCase();
+      if (model.includes("gpt-5.4"))
+        return 1050000;
       if (model.includes("gpt-5"))
-        return 256000;
-      if (model.includes("o1") || model.includes("o3"))
+        return 400000;
+      if (model.includes("o1") || model.includes("o3") || model.includes("o4"))
         return 200000;
       if (model.includes("gpt-4o") || model.includes("gpt-4-turbo"))
         return 128000;
@@ -33994,8 +34769,7 @@ var init_qwen_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      const lower = modelId.toLowerCase();
-      return lower.includes("qwen") || lower.includes("alibaba");
+      return matchesModelFamily(modelId, "qwen") || matchesModelFamily(modelId, "alibaba");
     }
     getName() {
       return "QwenAdapter";
@@ -34025,7 +34799,7 @@ var init_minimax_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      return modelId.includes("minimax");
+      return matchesModelFamily(modelId, "minimax");
     }
     getName() {
       return "MiniMaxAdapter";
@@ -34054,7 +34828,7 @@ var init_deepseek_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      return modelId.includes("deepseek");
+      return matchesModelFamily(modelId, "deepseek");
     }
     getName() {
       return "DeepSeekAdapter";
@@ -34068,18 +34842,20 @@ var init_glm_adapter = __esm(() => {
   init_base_adapter();
   init_logger();
   GLM_CONTEXT_WINDOWS = [
-    ["glm-5", 204800],
-    ["glm-4.7-flash", 200000],
-    ["glm-4.7", 204800],
-    ["glm-4.6v", 128000],
+    ["glm-5-turbo", 202752],
+    ["glm-5", 80000],
+    ["glm-4.7-flash", 202752],
+    ["glm-4.7", 202752],
+    ["glm-4.6v", 131072],
     ["glm-4.6", 204800],
-    ["glm-4.5v", 64000],
+    ["glm-4.5v", 65536],
     ["glm-4.5-flash", 131072],
     ["glm-4.5-air", 131072],
     ["glm-4.5", 131072],
     ["glm-4-long", 1e6],
     ["glm-4-plus", 128000],
     ["glm-4-flash", 128000],
+    ["glm-4-32b", 128000],
     ["glm-4", 128000],
     ["glm-3-turbo", 128000],
     ["glm-", 131072]
@@ -34101,7 +34877,7 @@ var init_glm_adapter = __esm(() => {
       return request;
     }
     shouldHandle(modelId) {
-      return modelId.includes("glm-") || modelId.includes("zhipu/");
+      return matchesModelFamily(modelId, "glm-") || matchesModelFamily(modelId, "chatglm-") || modelId.toLowerCase().includes("zhipu/");
     }
     getName() {
       return "GLMAdapter";
@@ -34121,6 +34897,42 @@ var init_glm_adapter = __esm(() => {
   };
 });
 
+// src/adapters/xiaomi-adapter.ts
+var XiaomiAdapter;
+var init_xiaomi_adapter = __esm(() => {
+  init_base_adapter();
+  init_logger();
+  XiaomiAdapter = class XiaomiAdapter extends BaseModelAdapter {
+    processTextContent(textContent, accumulatedText) {
+      return {
+        cleanedText: textContent,
+        extractedToolCalls: [],
+        wasTransformed: false
+      };
+    }
+    getToolNameLimit() {
+      return 64;
+    }
+    prepareRequest(request, originalRequest) {
+      if (originalRequest.thinking) {
+        log(`[XiaomiAdapter] Stripping thinking object (not supported by Xiaomi API)`);
+        delete request.thinking;
+      }
+      this.truncateToolNames(request);
+      if (request.messages) {
+        this.truncateToolNamesInMessages(request.messages);
+      }
+      return request;
+    }
+    shouldHandle(modelId) {
+      return matchesModelFamily(modelId, "xiaomi") || matchesModelFamily(modelId, "mimo");
+    }
+    getName() {
+      return "XiaomiAdapter";
+    }
+  };
+});
+
 // src/adapters/adapter-manager.ts
 var exports_adapter_manager = {};
 __export(exports_adapter_manager, {
@@ -34139,7 +34951,8 @@ class AdapterManager {
       new QwenAdapter(modelId),
       new MiniMaxAdapter(modelId),
       new DeepSeekAdapter(modelId),
-      new GLMAdapter(modelId)
+      new GLMAdapter(modelId),
+      new XiaomiAdapter(modelId)
     ];
     this.defaultAdapter = new DefaultAdapter(modelId);
   }
@@ -34165,6 +34978,7 @@ var init_adapter_manager = __esm(() => {
   init_minimax_adapter();
   init_deepseek_adapter();
   init_glm_adapter();
+  init_xiaomi_adapter();
 });
 
 // src/cli.ts
@@ -34181,31 +34995,31 @@ __export(exports_cli, {
   getMissingKeyError: () => getMissingKeyError
 });
 import {
-  readFileSync as readFileSync10,
-  writeFileSync as writeFileSync5,
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync6,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync6,
   copyFileSync,
-  readdirSync,
-  unlinkSync as unlinkSync3
+  readdirSync as readdirSync3,
+  unlinkSync as unlinkSync4
 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname3, join as join12 } from "path";
-import { homedir as homedir11 } from "os";
+import { dirname as dirname3, join as join13 } from "path";
+import { homedir as homedir12 } from "os";
 function getVersion() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join12(homedir11(), ".claudish");
-  if (!existsSync12(cacheDir))
+  const cacheDir = join13(homedir12(), ".claudish");
+  if (!existsSync13(cacheDir))
     return;
   const cachePatterns = ["all-models.json", "pricing-cache.json"];
   let cleared = 0;
   try {
-    const files = readdirSync(cacheDir);
+    const files = readdirSync3(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2) || file2.startsWith("litellm-models-")) {
-        unlinkSync3(join12(cacheDir, file2));
+        unlinkSync4(join13(cacheDir, file2));
         cleared++;
       }
     }
@@ -34229,6 +35043,7 @@ async function parseArgs(args) {
     monitor: false,
     stdin: false,
     freeOnly: false,
+    noLogs: false,
     claudeArgs: []
   };
   const claudishModel = process.env[ENV.CLAUDISH_MODEL];
@@ -34395,6 +35210,8 @@ async function parseArgs(args) {
       process.exit(0);
     } else if (arg === "--summarize-tools") {
       config3.summarizeTools = true;
+    } else if (arg === "--no-logs") {
+      config3.noLogs = true;
     } else if (arg === "--") {
       config3.claudeArgs.push(...args.slice(i + 1));
       break;
@@ -34496,9 +35313,9 @@ async function fetchOllamaModels() {
 }
 async function searchAndPrintModels(query, forceUpdate) {
   let models = [];
-  if (!forceUpdate && existsSync12(ALL_MODELS_JSON_PATH)) {
+  if (!forceUpdate && existsSync13(ALL_MODELS_JSON_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync10(ALL_MODELS_JSON_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync11(ALL_MODELS_JSON_PATH, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const now = new Date;
       const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
@@ -34515,8 +35332,8 @@ async function searchAndPrintModels(query, forceUpdate) {
         throw new Error(`API returned ${response.status}`);
       const data = await response.json();
       models = data.data;
-      mkdirSync5(CLAUDISH_CACHE_DIR2, { recursive: true });
-      writeFileSync5(ALL_MODELS_JSON_PATH, JSON.stringify({
+      mkdirSync6(CLAUDISH_CACHE_DIR2, { recursive: true });
+      writeFileSync6(ALL_MODELS_JSON_PATH, JSON.stringify({
         lastUpdated: new Date().toISOString(),
         models
       }), "utf-8");
@@ -34666,9 +35483,9 @@ Found ${results.length} matching models:
 async function printAllModels(jsonOutput, forceUpdate) {
   let models = [];
   const [ollamaModels, zenModels] = await Promise.all([fetchOllamaModels(), fetchZenModels()]);
-  if (!forceUpdate && existsSync12(ALL_MODELS_JSON_PATH)) {
+  if (!forceUpdate && existsSync13(ALL_MODELS_JSON_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync10(ALL_MODELS_JSON_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync11(ALL_MODELS_JSON_PATH, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const now = new Date;
       const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
@@ -34688,8 +35505,8 @@ async function printAllModels(jsonOutput, forceUpdate) {
         throw new Error(`API returned ${response.status}`);
       const data = await response.json();
       models = data.data;
-      mkdirSync5(CLAUDISH_CACHE_DIR2, { recursive: true });
-      writeFileSync5(ALL_MODELS_JSON_PATH, JSON.stringify({
+      mkdirSync6(CLAUDISH_CACHE_DIR2, { recursive: true });
+      writeFileSync6(ALL_MODELS_JSON_PATH, JSON.stringify({
         lastUpdated: new Date().toISOString(),
         models
       }), "utf-8");
@@ -34869,12 +35686,12 @@ async function printAllModels(jsonOutput, forceUpdate) {
   console.log("Top models:            claudish --top-models");
 }
 function isCacheStale() {
-  const cachePath = existsSync12(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-  if (!existsSync12(cachePath)) {
+  const cachePath = existsSync13(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
+  if (!existsSync13(cachePath)) {
     return true;
   }
   try {
-    const jsonContent = readFileSync10(cachePath, "utf-8");
+    const jsonContent = readFileSync11(cachePath, "utf-8");
     const data = JSON.parse(jsonContent);
     if (!data.lastUpdated) {
       return true;
@@ -34953,10 +35770,10 @@ async function updateModelsFromOpenRouter() {
       providers.add(provider);
     }
     let version2 = "1.2.0";
-    const existingPath = existsSync12(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-    if (existsSync12(existingPath)) {
+    const existingPath = existsSync13(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
+    if (existsSync13(existingPath)) {
       try {
-        const existing = JSON.parse(readFileSync10(existingPath, "utf-8"));
+        const existing = JSON.parse(readFileSync11(existingPath, "utf-8"));
         version2 = existing.version || version2;
       } catch {}
     }
@@ -34966,8 +35783,8 @@ async function updateModelsFromOpenRouter() {
       source: "https://openrouter.ai/models?categories=programming&fmt=cards&order=top-weekly",
       models: recommendations
     };
-    mkdirSync5(CLAUDISH_CACHE_DIR2, { recursive: true });
-    writeFileSync5(CACHED_MODELS_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
+    mkdirSync6(CLAUDISH_CACHE_DIR2, { recursive: true });
+    writeFileSync6(CACHED_MODELS_PATH, JSON.stringify(updatedData, null, 2), "utf-8");
     console.error(`\u2705 Updated ${recommendations.length} models (last updated: ${updatedData.lastUpdated})`);
   } catch (error46) {
     console.error(`\u274C Failed to update models: ${error46 instanceof Error ? error46.message : String(error46)}`);
@@ -34985,8 +35802,8 @@ async function checkAndUpdateModelsCache(forceUpdate = false) {
     await updateModelsFromOpenRouter();
   } else {
     try {
-      const cachePath = existsSync12(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-      const data = JSON.parse(readFileSync10(cachePath, "utf-8"));
+      const cachePath = existsSync13(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
+      const data = JSON.parse(readFileSync11(cachePath, "utf-8"));
       console.error(`\u2713 Using cached models (last updated: ${data.lastUpdated})`);
     } catch {}
   }
@@ -35293,6 +36110,7 @@ OPTIONS:
   -p, --profile <name>     Use named profile for model mapping (default: uses default profile)
   --port <port>            Proxy server port (default: random)
   -d, --debug              Enable debug logging to file (logs/claudish_*.log)
+  --no-logs                Disable always-on structural logging (~/.claudish/logs/)
   --log-level <level>      Log verbosity: debug (full), info (truncated), minimal (labels only)
   -q, --quiet              Suppress [claudish] log messages (default in single-shot mode)
   -v, --verbose            Show [claudish] log messages (default in interactive mode)
@@ -35544,8 +36362,8 @@ MORE INFO:
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join12(__dirname4, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync10(guidePath, "utf-8");
+    const guidePath = join13(__dirname4, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync11(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -35561,19 +36379,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join12(cwd, ".claude");
-  const skillsDir = join12(claudeDir, "skills");
-  const claudishSkillDir = join12(skillsDir, "claudish-usage");
-  const skillFile = join12(claudishSkillDir, "SKILL.md");
-  if (existsSync12(skillFile)) {
+  const claudeDir = join13(cwd, ".claude");
+  const skillsDir = join13(claudeDir, "skills");
+  const claudishSkillDir = join13(skillsDir, "claudish-usage");
+  const skillFile = join13(claudishSkillDir, "SKILL.md");
+  if (existsSync13(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join12(__dirname4, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync12(sourceSkillPath)) {
+  const sourceSkillPath = join13(__dirname4, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync13(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -35582,16 +36400,16 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync12(claudeDir)) {
-      mkdirSync5(claudeDir, { recursive: true });
+    if (!existsSync13(claudeDir)) {
+      mkdirSync6(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync12(skillsDir)) {
-      mkdirSync5(skillsDir, { recursive: true });
+    if (!existsSync13(skillsDir)) {
+      mkdirSync6(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync12(claudishSkillDir)) {
-      mkdirSync5(claudishSkillDir, { recursive: true });
+    if (!existsSync13(claudishSkillDir)) {
+      mkdirSync6(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync(sourceSkillPath, skillFile);
@@ -35633,9 +36451,9 @@ function printAvailableModels() {
   let lastUpdated = "unknown";
   let models = [];
   try {
-    const cachePath = existsSync12(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
-    if (existsSync12(cachePath)) {
-      const data = JSON.parse(readFileSync10(cachePath, "utf-8"));
+    const cachePath = existsSync13(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
+    if (existsSync13(cachePath)) {
+      const data = JSON.parse(readFileSync11(cachePath, "utf-8"));
       lastUpdated = data.lastUpdated || "unknown";
       models = data.models || [];
     }
@@ -35684,9 +36502,9 @@ Force update: claudish --list-models --force-update
 `);
 }
 function printAvailableModelsJSON() {
-  const jsonPath = existsSync12(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
+  const jsonPath = existsSync13(CACHED_MODELS_PATH) ? CACHED_MODELS_PATH : BUNDLED_MODELS_PATH;
   try {
-    const jsonContent = readFileSync10(jsonPath, "utf-8");
+    const jsonContent = readFileSync11(jsonPath, "utf-8");
     const data = JSON.parse(jsonContent);
     console.log(JSON.stringify(data, null, 2));
   } catch (error46) {
@@ -35771,7 +36589,7 @@ async function fetchGLMCodingModels() {
     return [];
   }
 }
-var __filename4, __dirname4, VERSION = "5.14.0", CACHE_MAX_AGE_DAYS2 = 2, CLAUDISH_CACHE_DIR2, BUNDLED_MODELS_PATH, CACHED_MODELS_PATH, ALL_MODELS_JSON_PATH;
+var __filename4, __dirname4, VERSION = "5.16.0", CACHE_MAX_AGE_DAYS2 = 2, CLAUDISH_CACHE_DIR2, BUNDLED_MODELS_PATH, CACHED_MODELS_PATH, ALL_MODELS_JSON_PATH;
 var init_cli = __esm(() => {
   init_config();
   init_model_loader();
@@ -35783,13 +36601,13 @@ var init_cli = __esm(() => {
   __filename4 = fileURLToPath3(import.meta.url);
   __dirname4 = dirname3(__filename4);
   try {
-    const packageJson = JSON.parse(readFileSync10(join12(__dirname4, "../package.json"), "utf-8"));
+    const packageJson = JSON.parse(readFileSync11(join13(__dirname4, "../package.json"), "utf-8"));
     VERSION = packageJson.version;
   } catch {}
-  CLAUDISH_CACHE_DIR2 = join12(homedir11(), ".claudish");
-  BUNDLED_MODELS_PATH = join12(__dirname4, "../recommended-models.json");
-  CACHED_MODELS_PATH = join12(CLAUDISH_CACHE_DIR2, "recommended-models.json");
-  ALL_MODELS_JSON_PATH = join12(CLAUDISH_CACHE_DIR2, "all-models.json");
+  CLAUDISH_CACHE_DIR2 = join13(homedir12(), ".claudish");
+  BUNDLED_MODELS_PATH = join13(__dirname4, "../recommended-models.json");
+  CACHED_MODELS_PATH = join13(CLAUDISH_CACHE_DIR2, "recommended-models.json");
+  ALL_MODELS_JSON_PATH = join13(CLAUDISH_CACHE_DIR2, "all-models.json");
 });
 
 // src/update-checker.ts
@@ -35801,9 +36619,9 @@ __export(exports_update_checker, {
   checkForUpdates: () => checkForUpdates
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync4, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir12, platform as platform2, tmpdir } from "os";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readFileSync as readFileSync12, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7 } from "fs";
+import { homedir as homedir13, platform as platform2, tmpdir } from "os";
+import { join as join14 } from "path";
 import { createInterface } from "readline";
 function getUpdateCommand() {
   const scriptPath = process.argv[1] || "";
@@ -35815,27 +36633,27 @@ function getUpdateCommand() {
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join13(homedir12(), "AppData", "Local");
-    cacheDir = join13(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join14(homedir13(), "AppData", "Local");
+    cacheDir = join14(localAppData, "claudish");
   } else {
-    cacheDir = join13(homedir12(), ".cache", "claudish");
+    cacheDir = join14(homedir13(), ".cache", "claudish");
   }
   try {
-    if (!existsSync13(cacheDir)) {
-      mkdirSync6(cacheDir, { recursive: true });
+    if (!existsSync14(cacheDir)) {
+      mkdirSync7(cacheDir, { recursive: true });
     }
-    return join13(cacheDir, "update-check.json");
+    return join14(cacheDir, "update-check.json");
   } catch {
-    return join13(tmpdir(), "claudish-update-check.json");
+    return join14(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync13(cachePath)) {
+    if (!existsSync14(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync11(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync12(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -35848,7 +36666,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync6(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync7(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {
@@ -35858,8 +36676,8 @@ function isCacheValid(cache) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync13(cachePath)) {
-      unlinkSync4(cachePath);
+    if (existsSync14(cachePath)) {
+      unlinkSync5(cachePath);
     }
   } catch {}
 }
@@ -35895,7 +36713,7 @@ async function fetchLatestVersion() {
   }
 }
 function promptUser(question) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const rl = createInterface({
       input: process.stdin,
       output: process.stderr
@@ -35903,7 +36721,7 @@ function promptUser(question) {
     rl.question(question, (answer) => {
       rl.close();
       const normalized = answer.toLowerCase().trim();
-      resolve(normalized === "y" || normalized === "yes");
+      resolve2(normalized === "y" || normalized === "yes");
     });
   });
 }
@@ -36014,7 +36832,7 @@ function getUpdateCommand2(method) {
   }
 }
 function promptUser2(question) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const rl = createInterface2({
       input: process.stdin,
       output: process.stdout
@@ -36022,7 +36840,7 @@ function promptUser2(question) {
     rl.question(question, (answer) => {
       rl.close();
       const normalized = answer.toLowerCase().trim();
-      resolve(normalized === "y" || normalized === "yes" || normalized === "");
+      resolve2(normalized === "y" || normalized === "yes" || normalized === "");
     });
   });
 }
@@ -37708,13 +38526,13 @@ var PromisePolyfill;
 var init_promise_polyfill = __esm(() => {
   PromisePolyfill = class PromisePolyfill extends Promise {
     static withResolver() {
-      let resolve;
+      let resolve2;
       let reject;
       const promise3 = new Promise((res, rej) => {
-        resolve = res;
+        resolve2 = res;
         reject = rej;
       });
-      return { promise: promise3, resolve, reject };
+      return { promise: promise3, resolve: resolve2, reject };
     }
   };
 });
@@ -37751,7 +38569,7 @@ function createPrompt(view) {
       output
     });
     const screen = new ScreenManager(rl);
-    const { promise: promise3, resolve, reject } = PromisePolyfill.withResolver();
+    const { promise: promise3, resolve: resolve2, reject } = PromisePolyfill.withResolver();
     const cancel = () => reject(new CancelPromptError);
     if (signal) {
       const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -37778,7 +38596,7 @@ function createPrompt(view) {
       cycle(() => {
         try {
           const nextView = view(config3, (value) => {
-            setImmediate(() => resolve(value));
+            setImmediate(() => resolve2(value));
           });
           if (nextView === undefined) {
             const callerFilename = callSites[1]?.getFileName();
@@ -38339,14 +39157,14 @@ __export(exports_model_selector, {
   promptForApiKey: () => promptForApiKey,
   confirmAction: () => confirmAction
 });
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, existsSync as existsSync14, mkdirSync as mkdirSync7 } from "fs";
-import { join as join14, dirname as dirname4 } from "path";
-import { homedir as homedir13 } from "os";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync8, existsSync as existsSync15, mkdirSync as mkdirSync8 } from "fs";
+import { join as join15, dirname as dirname4 } from "path";
+import { homedir as homedir14 } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function loadRecommendedModels2() {
-  if (existsSync14(RECOMMENDED_MODELS_JSON_PATH)) {
+  if (existsSync15(RECOMMENDED_MODELS_JSON_PATH)) {
     try {
-      const content = readFileSync12(RECOMMENDED_MODELS_JSON_PATH, "utf-8");
+      const content = readFileSync13(RECOMMENDED_MODELS_JSON_PATH, "utf-8");
       const data = JSON.parse(content);
       return (data.models || []).map((model) => ({
         ...model,
@@ -38359,9 +39177,9 @@ function loadRecommendedModels2() {
   return [];
 }
 async function fetchAllModels(forceUpdate = false) {
-  if (!forceUpdate && existsSync14(ALL_MODELS_JSON_PATH2)) {
+  if (!forceUpdate && existsSync15(ALL_MODELS_JSON_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync12(ALL_MODELS_JSON_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync13(ALL_MODELS_JSON_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const now = new Date;
       const ageInDays = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
@@ -38377,8 +39195,8 @@ async function fetchAllModels(forceUpdate = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data;
-    mkdirSync7(CLAUDISH_CACHE_DIR3, { recursive: true });
-    writeFileSync7(ALL_MODELS_JSON_PATH2, JSON.stringify({
+    mkdirSync8(CLAUDISH_CACHE_DIR3, { recursive: true });
+    writeFileSync8(ALL_MODELS_JSON_PATH2, JSON.stringify({
       lastUpdated: new Date().toISOString(),
       models
     }), "utf-8");
@@ -38863,11 +39681,11 @@ async function fetchOllamaCloudModels() {
   }
 }
 function shouldRefreshForFreeModels() {
-  if (!existsSync14(ALL_MODELS_JSON_PATH2)) {
+  if (!existsSync15(ALL_MODELS_JSON_PATH2)) {
     return true;
   }
   try {
-    const cacheData = JSON.parse(readFileSync12(ALL_MODELS_JSON_PATH2, "utf-8"));
+    const cacheData = JSON.parse(readFileSync13(ALL_MODELS_JSON_PATH2, "utf-8"));
     const lastUpdated = new Date(cacheData.lastUpdated);
     const now = new Date;
     const ageInHours = (now.getTime() - lastUpdated.getTime()) / (1000 * 60 * 60);
@@ -39468,9 +40286,9 @@ var init_model_selector = __esm(() => {
   init_model_loader();
   __filename5 = fileURLToPath4(import.meta.url);
   __dirname5 = dirname4(__filename5);
-  CLAUDISH_CACHE_DIR3 = join14(homedir13(), ".claudish");
-  ALL_MODELS_JSON_PATH2 = join14(CLAUDISH_CACHE_DIR3, "all-models.json");
-  RECOMMENDED_MODELS_JSON_PATH = join14(__dirname5, "../recommended-models.json");
+  CLAUDISH_CACHE_DIR3 = join15(homedir14(), ".claudish");
+  ALL_MODELS_JSON_PATH2 = join15(CLAUDISH_CACHE_DIR3, "all-models.json");
+  RECOMMENDED_MODELS_JSON_PATH = join15(__dirname5, "../recommended-models.json");
   PROVIDER_FILTER_ALIASES = {
     zen: "Zen",
     openrouter: "OpenRouter",
@@ -40328,11 +41146,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 = createInterface4({ 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";
@@ -40516,25 +41334,25 @@ var init_telemetry = __esm(() => {
 
 // src/stats-buffer.ts
 import {
-  existsSync as existsSync15,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync13,
+  existsSync as existsSync16,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync14,
   renameSync,
-  unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync8
+  unlinkSync as unlinkSync6,
+  writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join15 } from "path";
+import { homedir as homedir15 } from "os";
+import { join as join16 } from "path";
 function ensureDir() {
-  if (!existsSync15(CLAUDISH_DIR)) {
-    mkdirSync8(CLAUDISH_DIR, { recursive: true });
+  if (!existsSync16(CLAUDISH_DIR)) {
+    mkdirSync9(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
   try {
-    if (!existsSync15(BUFFER_FILE))
+    if (!existsSync16(BUFFER_FILE))
       return [];
-    const raw = readFileSync13(BUFFER_FILE, "utf-8");
+    const raw = readFileSync14(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.events))
       return [];
@@ -40558,8 +41376,8 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed };
-    const tmpFile = join15(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
-    writeFileSync8(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
+    const tmpFile = join16(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    writeFileSync9(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync(tmpFile, BUFFER_FILE);
     memoryCache = trimmed;
   } catch {}
@@ -40603,8 +41421,8 @@ function clearBuffer() {
   try {
     memoryCache = [];
     eventsSinceLastFlush = 0;
-    if (existsSync15(BUFFER_FILE)) {
-      unlinkSync5(BUFFER_FILE);
+    if (existsSync16(BUFFER_FILE)) {
+      unlinkSync6(BUFFER_FILE);
     }
   } catch {}
 }
@@ -40632,8 +41450,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, lastFlushTime, flushScheduled = false;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join15(homedir14(), ".claudish");
-  BUFFER_FILE = join15(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join16(homedir15(), ".claudish");
+  BUFFER_FILE = join16(CLAUDISH_DIR, "stats-buffer.json");
   lastFlushTime = Date.now();
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
@@ -41118,16 +41936,16 @@ import { EventEmitter } from "events";
 import { Buffer as Buffer2 } from "buffer";
 import { Buffer as Buffer3 } from "buffer";
 import { EventEmitter as EventEmitter2 } from "events";
-import { resolve, dirname as dirname5 } from "path";
+import { resolve as resolve2, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { resolve as resolve2, isAbsolute, parse as parse6 } from "path";
-import { existsSync as existsSync16 } from "fs";
-import { basename, join as join16 } from "path";
+import { resolve as resolve22, isAbsolute, parse as parse6 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { basename, join as join17 } from "path";
 import os from "os";
 import path from "path";
 import { EventEmitter as EventEmitter3 } from "events";
 import { dlopen, toArrayBuffer as toArrayBuffer4, JSCallback, ptr as ptr4 } from "bun:ffi";
-import { existsSync as existsSync22, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync22, writeFileSync as writeFileSync10 } from "fs";
 import { EventEmitter as EventEmitter4 } from "events";
 import { toArrayBuffer, ptr } from "bun:ffi";
 import { ptr as ptr2, toArrayBuffer as toArrayBuffer2 } from "bun:ffi";
@@ -43463,24 +44281,24 @@ function getParsers() {
       {
         filetype: "javascript",
         queries: {
-          highlights: [resolve(dirname5(fileURLToPath5(import.meta.url)), highlights_default)]
+          highlights: [resolve2(dirname5(fileURLToPath5(import.meta.url)), highlights_default)]
         },
-        wasm: resolve(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_javascript_default)
+        wasm: resolve2(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_javascript_default)
       },
       {
         filetype: "typescript",
         queries: {
-          highlights: [resolve(dirname5(fileURLToPath5(import.meta.url)), highlights_default2)]
+          highlights: [resolve2(dirname5(fileURLToPath5(import.meta.url)), highlights_default2)]
         },
-        wasm: resolve(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_typescript_default)
+        wasm: resolve2(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_typescript_default)
       },
       {
         filetype: "markdown",
         queries: {
-          highlights: [resolve(dirname5(fileURLToPath5(import.meta.url)), highlights_default3)],
-          injections: [resolve(dirname5(fileURLToPath5(import.meta.url)), injections_default)]
+          highlights: [resolve2(dirname5(fileURLToPath5(import.meta.url)), highlights_default3)],
+          injections: [resolve2(dirname5(fileURLToPath5(import.meta.url)), injections_default)]
         },
-        wasm: resolve(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_markdown_default),
+        wasm: resolve2(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_markdown_default),
         injectionMapping: {
           nodeTypes: {
             inline: "markdown_inline",
@@ -43499,16 +44317,16 @@ function getParsers() {
       {
         filetype: "markdown_inline",
         queries: {
-          highlights: [resolve(dirname5(fileURLToPath5(import.meta.url)), highlights_default4)]
+          highlights: [resolve2(dirname5(fileURLToPath5(import.meta.url)), highlights_default4)]
         },
-        wasm: resolve(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_markdown_inline_default)
+        wasm: resolve2(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_markdown_inline_default)
       },
       {
         filetype: "zig",
         queries: {
-          highlights: [resolve(dirname5(fileURLToPath5(import.meta.url)), highlights_default5)]
+          highlights: [resolve2(dirname5(fileURLToPath5(import.meta.url)), highlights_default5)]
         },
-        wasm: resolve(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_zig_default)
+        wasm: resolve2(dirname5(fileURLToPath5(import.meta.url)), tree_sitter_zig_default)
       }
     ];
   }
@@ -43521,7 +44339,7 @@ function getBunfsRootPath() {
   return process.platform === "win32" ? "B:\\~BUN\\root" : "/$bunfs/root";
 }
 function normalizeBunfsPath(fileName) {
-  return join16(getBunfsRootPath(), basename(fileName));
+  return join17(getBunfsRootPath(), basename(fileName));
 }
 function isValidDirectoryName(name) {
   if (!name || typeof name !== "string") {
@@ -46473,7 +47291,7 @@ function convertToDebugSymbols(symbols) {
   if (env.OTUI_DEBUG_FFI && globalFFILogPath) {
     const logPath = globalFFILogPath;
     const writeSync3 = (msg) => {
-      writeFileSync9(logPath, msg + `
+      writeFileSync10(logPath, msg + `
 `, { flag: "a" });
     };
     Object.entries(symbols).forEach(([key, value]) => {
@@ -53717,7 +54535,7 @@ var init_index_0wbvecnk = __esm(async () => {
         worker_path = this.options.workerPath;
       } else {
         worker_path = new URL("./parser.worker.js", import.meta.url).href;
-        if (!existsSync16(resolve2(import.meta.dirname, "parser.worker.js"))) {
+        if (!existsSync17(resolve22(import.meta.dirname, "parser.worker.js"))) {
           worker_path = new URL("./parser.worker.ts", import.meta.url).href;
         }
       }
@@ -53783,7 +54601,7 @@ var init_index_0wbvecnk = __esm(async () => {
         return normalizeBunfsPath(parse6(path2).base);
       }
       if (!isAbsolute(path2)) {
-        return resolve2(path2);
+        return resolve22(path2);
       }
       return path2;
     }
@@ -82869,9 +83687,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         }
         function getWrappedDisplayName(outerType, innerType, wrapperName, fallbackName) {
           var displayName = outerType === null || outerType === undefined ? undefined : outerType.displayName;
-          return displayName || "".concat(wrapperName, "(").concat(getDisplayName(innerType, fallbackName), ")");
+          return displayName || "".concat(wrapperName, "(").concat(getDisplayName2(innerType, fallbackName), ")");
         }
-        function getDisplayName(type) {
+        function getDisplayName2(type) {
           var fallbackName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "Anonymous";
           var nameFromCache = cachedDisplayNames.get(type);
           if (nameFromCache != null) {
@@ -83414,7 +84232,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               if (typeof type === "string") {
                 return type;
               } else if (typeof type === "function") {
-                return getDisplayName(type, "Anonymous");
+                return getDisplayName2(type, "Anonymous");
               } else if (type != null) {
                 return "NotImplementedInDevtools";
               } else {
@@ -89342,7 +90160,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               case IncompleteFunctionComponent:
               case FunctionComponent:
               case IndeterminateComponent:
-                return getDisplayName(resolvedType);
+                return getDisplayName2(resolvedType);
               case ForwardRef:
                 return getWrappedDisplayName(elementType, resolvedType, "ForwardRef", "Anonymous");
               case HostRoot:
@@ -94297,7 +95115,7 @@ The error thrown in the component is:
             if (typeof elementType === "string") {
               displayName = elementType;
             } else if (typeof elementType === "function") {
-              displayName = getDisplayName(elementType);
+              displayName = getDisplayName2(elementType);
             }
           }
           return {
@@ -98429,24 +99247,163 @@ var init_tui = __esm(async () => {
   }
 });
 
+// src/team-cli.ts
+var exports_team_cli = {};
+__export(exports_team_cli, {
+  teamCommand: () => teamCommand
+});
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join18 } from "path";
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length)
+    return;
+  return args[idx + 1];
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function printStatus(status) {
+  const modelIds = Object.keys(status.models).sort();
+  console.log(`
+Team Status (started: ${status.startedAt})`);
+  console.log("\u2500".repeat(60));
+  for (const id of modelIds) {
+    const m2 = status.models[id];
+    const duration3 = m2.startedAt && m2.completedAt ? `${Math.round((new Date(m2.completedAt).getTime() - new Date(m2.startedAt).getTime()) / 1000)}s` : m2.startedAt ? "running" : "pending";
+    const size = m2.outputSize > 0 ? ` (${m2.outputSize} bytes)` : "";
+    console.log(`  ${id}  ${m2.state.padEnd(10)}  ${duration3}${size}`);
+  }
+  console.log("");
+}
+function printHelp2() {
+  console.log(`
+Usage: claudish team <subcommand> [options]
+
+Subcommands:
+  run             Run multiple models on a task in parallel
+  judge           Blind-judge existing model outputs
+  run-and-judge   Run models then judge their outputs
+  status          Show current session status
+
+Options (run / run-and-judge):
+  --path <dir>        Session directory (default: .)
+  --models <a,b,...>  Comma-separated model IDs to run
+  --input <text>      Task prompt (or create input.md in --path beforehand)
+  --timeout <secs>    Timeout per model in seconds (default: 300)
+
+Options (judge / run-and-judge):
+  --judges <a,b,...>  Comma-separated judge model IDs (default: same as runners)
+
+Options (status):
+  --path <dir>        Session directory (default: .)
+
+Examples:
+  claudish team run --path ./review --models minimax-m2.5,kimi-k2.5 --input "Review this code"
+  claudish team judge --path ./review
+  claudish team run-and-judge --path ./review --models gpt-5.4,gemini-3.1-pro-preview --input "Evaluate this design"
+  claudish team status --path ./review
+`);
+}
+async function teamCommand(args) {
+  const subcommand = args[0];
+  if (!subcommand || hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printHelp2();
+    process.exit(0);
+  }
+  const rawSessionPath = getFlag(args, "--path") ?? ".";
+  let sessionPath;
+  try {
+    sessionPath = validateSessionPath(rawSessionPath);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const modelsRaw = getFlag(args, "--models");
+  const judgesRaw = getFlag(args, "--judges");
+  const input = getFlag(args, "--input");
+  const timeoutStr = getFlag(args, "--timeout");
+  const timeout = timeoutStr ? parseInt(timeoutStr, 10) : 300;
+  const models = modelsRaw ? modelsRaw.split(",").map((m2) => m2.trim()).filter(Boolean) : [];
+  const judges = judgesRaw ? judgesRaw.split(",").map((m2) => m2.trim()).filter(Boolean) : undefined;
+  switch (subcommand) {
+    case "run": {
+      if (models.length === 0) {
+        console.error("Error: --models is required for 'run'");
+        process.exit(1);
+      }
+      setupSession(sessionPath, models, input);
+      const runStatus = await runModels(sessionPath, {
+        timeout,
+        onStatusChange: (id, s) => {
+          process.stderr.write(`[team] ${id}: ${s.state}
+`);
+        }
+      });
+      printStatus(runStatus);
+      break;
+    }
+    case "judge": {
+      const verdict = await judgeResponses(sessionPath, { judges });
+      console.log(readFileSync15(join18(sessionPath, "verdict.md"), "utf-8"));
+      break;
+    }
+    case "run-and-judge": {
+      if (models.length === 0) {
+        console.error("Error: --models is required for 'run-and-judge'");
+        process.exit(1);
+      }
+      setupSession(sessionPath, models, input);
+      const status = await runModels(sessionPath, {
+        timeout,
+        onStatusChange: (id, s) => {
+          process.stderr.write(`[team] ${id}: ${s.state}
+`);
+        }
+      });
+      printStatus(status);
+      await judgeResponses(sessionPath, { judges });
+      console.log(readFileSync15(join18(sessionPath, "verdict.md"), "utf-8"));
+      break;
+    }
+    case "status": {
+      const status = getStatus(sessionPath);
+      printStatus(status);
+      break;
+    }
+    default: {
+      console.error(`Unknown team subcommand: ${subcommand}`);
+      printHelp2();
+      process.exit(1);
+    }
+  }
+}
+var init_team_cli = __esm(() => {
+  init_team_orchestrator();
+});
+
 // src/claude-runner.ts
 var exports_claude_runner = {};
 __export(exports_claude_runner, {
   runClaudeWithProxy: () => runClaudeWithProxy,
   checkClaudeInstalled: () => checkClaudeInstalled
 });
-import { spawn } from "child_process";
-import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync6, mkdirSync as mkdirSync9, existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
-import { tmpdir as tmpdir2, homedir as homedir15 } from "os";
-import { join as join17 } from "path";
+import { spawn as spawn2 } from "child_process";
+import { writeFileSync as writeFileSync11, unlinkSync as unlinkSync7, mkdirSync as mkdirSync10, existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
+import { tmpdir as tmpdir2, homedir as homedir16 } from "os";
+import { join as join19 } from "path";
+function hasNativeAnthropicMapping(config3) {
+  const models = [config3.model, config3.modelOpus, config3.modelSonnet, config3.modelHaiku, config3.modelSubagent];
+  return models.some((m2) => m2 && parseModelSpec(m2).provider === "native-anthropic");
+}
 function isWindows2() {
   return process.platform === "win32";
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join17(homeDir, ".claudish");
+  const claudishDir = join19(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join17(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join19(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -98526,18 +99483,18 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync10(scriptPath, script, "utf-8");
+  writeFileSync11(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function createTempSettingsFile(modelDisplay, port) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join17(homeDir, ".claudish");
+  const claudishDir = join19(homeDir, ".claudish");
   try {
-    mkdirSync9(claudishDir, { recursive: true });
+    mkdirSync10(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join17(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join17(claudishDir, `tokens-${port}.json`);
+  const tempPath = join19(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join19(claudishDir, `tokens-${port}.json`);
   let statusCommand;
   if (isWindows2()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
@@ -98559,7 +99516,7 @@ function createTempSettingsFile(modelDisplay, port) {
     padding: 0
   };
   const settings = { statusLine };
-  writeFileSync10(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync11(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine };
 }
 function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
@@ -98573,11 +99530,11 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
     if (userSettingsValue.trimStart().startsWith("{")) {
       userSettings = JSON.parse(userSettingsValue);
     } else {
-      const rawUserSettings = readFileSync14(userSettingsValue, "utf-8");
+      const rawUserSettings = readFileSync16(userSettingsValue, "utf-8");
       userSettings = JSON.parse(rawUserSettings);
     }
     userSettings.statusLine = statusLine;
-    writeFileSync10(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync11(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -98585,7 +99542,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
   }
   config3.claudeArgs.splice(idx, 2);
 }
-async function runClaudeWithProxy(config3, proxyUrl) {
+async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
   const hasProfileMappings = config3.modelOpus || config3.modelSonnet || config3.modelHaiku || config3.modelSubagent;
   const modelId = config3.model || (hasProfileMappings || config3.monitor ? undefined : "unknown");
   const portMatch = proxyUrl.match(/:(\d+)/);
@@ -98636,14 +99593,19 @@ async function runClaudeWithProxy(config3, proxyUrl) {
       env2[ENV.ANTHROPIC_MODEL] = modelId;
       env2[ENV.ANTHROPIC_SMALL_FAST_MODEL] = modelId;
     }
-    env2.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx";
-    env2.ANTHROPIC_AUTH_TOKEN = process.env.ANTHROPIC_AUTH_TOKEN || "placeholder-token-not-used-proxy-handles-auth";
+    if (hasNativeAnthropicMapping(config3)) {} else {
+      env2.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx";
+      env2.ANTHROPIC_AUTH_TOKEN = process.env.ANTHROPIC_AUTH_TOKEN || "placeholder-token-not-used-proxy-handles-auth";
+    }
   }
   const log2 = (message) => {
     if (!config3.quiet) {
       console.log(message);
     }
   };
+  if (!config3.monitor && hasNativeAnthropicMapping(config3)) {
+    log2("[claudish] Native Claude model detected \u2014 using Claude Code subscription credentials");
+  }
   if (config3.interactive) {
     log2(`
 [claudish] Model: ${modelDisplayName}
@@ -98660,30 +99622,30 @@ async function runClaudeWithProxy(config3, proxyUrl) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir15();
-    const localPath = isWindows2() ? join17(home, ".claude", "local", "claude.exe") : join17(home, ".claude", "local", "claude");
+    const home = homedir16();
+    const localPath = isWindows2() ? join19(home, ".claude", "local", "claude.exe") : join19(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
   const needsShell = isWindows2() && claudeBinary.endsWith(".cmd");
   const spawnCommand = needsShell ? `"${claudeBinary}"` : claudeBinary;
-  const proc = spawn(spawnCommand, claudeArgs, {
+  const proc = spawn2(spawnCommand, claudeArgs, {
     env: env2,
     stdio: "inherit",
     shell: needsShell
   });
-  setupSignalHandlers(proc, tempSettingsPath, config3.quiet);
+  setupSignalHandlers(proc, tempSettingsPath, config3.quiet, onCleanup);
   const exitCode = await new Promise((resolve3) => {
     proc.on("exit", (code) => {
       resolve3(code ?? 1);
     });
   });
   try {
-    unlinkSync6(tempSettingsPath);
+    unlinkSync7(tempSettingsPath);
   } catch (error46) {}
   return exitCode;
 }
-function setupSignalHandlers(proc, tempSettingsPath, quiet) {
+function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
   const signals2 = isWindows2() ? ["SIGINT", "SIGTERM"] : ["SIGINT", "SIGTERM", "SIGHUP"];
   for (const signal of signals2) {
     process.on(signal, () => {
@@ -98692,8 +99654,13 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet) {
 [claudish] Received ${signal}, shutting down...`);
       }
       proc.kill();
+      if (onCleanup) {
+        try {
+          onCleanup();
+        } catch {}
+      }
       try {
-        unlinkSync6(tempSettingsPath);
+        unlinkSync7(tempSettingsPath);
       } catch {}
       process.exit(0);
     });
@@ -98702,23 +99669,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync17(process.env.CLAUDE_PATH)) {
+    if (existsSync18(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir15();
-  const localPath = isWindows3 ? join17(home, ".claude", "local", "claude.exe") : join17(home, ".claude", "local", "claude");
-  if (existsSync17(localPath)) {
+  const home = homedir16();
+  const localPath = isWindows3 ? join19(home, ".claude", "local", "claude.exe") : join19(home, ".claude", "local", "claude");
+  if (existsSync18(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join17(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join17(home, ".npm-global", "claude.cmd"),
-      join17(home, "node_modules", ".bin", "claude.cmd")
+      join19(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join19(home, ".npm-global", "claude.cmd"),
+      join19(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync17(path2)) {
+      if (existsSync18(path2)) {
         return path2;
       }
     }
@@ -98726,21 +99693,21 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join17(home, ".npm-global/bin/claude"),
-      join17(home, ".local/bin/claude"),
-      join17(home, "node_modules/.bin/claude"),
+      join19(home, ".npm-global/bin/claude"),
+      join19(home, ".local/bin/claude"),
+      join19(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join17(home, "../usr/bin/claude")
+      join19(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync17(path2)) {
+      if (existsSync18(path2)) {
         return path2;
       }
     }
   }
   try {
     const shellCommand = isWindows3 ? "where claude" : "command -v claude";
-    const proc = spawn(shellCommand, [], {
+    const proc = spawn2(shellCommand, [], {
       stdio: "pipe",
       shell: true
     });
@@ -98772,6 +99739,106 @@ async function checkClaudeInstalled() {
 }
 var init_claude_runner = __esm(() => {
   init_config();
+  init_model_parser();
+});
+
+// src/diag-output.ts
+var exports_diag_output = {};
+__export(exports_diag_output, {
+  createDiagOutput: () => createDiagOutput,
+  TmuxDiagOutput: () => TmuxDiagOutput,
+  NullDiagOutput: () => NullDiagOutput,
+  LogFileDiagOutput: () => LogFileDiagOutput
+});
+import { createWriteStream as createWriteStream2, mkdirSync as mkdirSync11, writeFileSync as writeFileSync12, unlinkSync as unlinkSync8 } from "fs";
+import { execFileSync } from "child_process";
+import { homedir as homedir17 } from "os";
+import { join as join20 } from "path";
+function getClaudishDir() {
+  const dir = join20(homedir17(), ".claudish");
+  try {
+    mkdirSync11(dir, { recursive: true });
+  } catch {}
+  return dir;
+}
+function getDiagLogPath() {
+  return join20(getClaudishDir(), `diag-${process.pid}.log`);
+}
+
+class LogFileDiagOutput {
+  logPath;
+  stream;
+  constructor() {
+    this.logPath = getDiagLogPath();
+    try {
+      writeFileSync12(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+`);
+    } catch {}
+    this.stream = createWriteStream2(this.logPath, { flags: "a" });
+    this.stream.on("error", () => {});
+  }
+  write(msg) {
+    const timestamp = new Date().toISOString();
+    const line = `[${timestamp}] ${msg}
+`;
+    try {
+      this.stream.write(line);
+    } catch {}
+  }
+  cleanup() {
+    try {
+      this.stream.end();
+    } catch {}
+    try {
+      unlinkSync8(this.logPath);
+    } catch {}
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+}
+
+class NullDiagOutput {
+  write(_msg) {}
+  cleanup() {}
+}
+function createDiagOutput(options) {
+  if (!options.interactive) {
+    return new NullDiagOutput;
+  }
+  if (process.env.TMUX) {
+    return new TmuxDiagOutput;
+  }
+  return new LogFileDiagOutput;
+}
+var TmuxDiagOutput;
+var init_diag_output = __esm(() => {
+  TmuxDiagOutput = class TmuxDiagOutput extends LogFileDiagOutput {
+    paneId = null;
+    constructor() {
+      super();
+      this.openTmuxPane();
+    }
+    openTmuxPane() {
+      try {
+        const output = execFileSync("tmux", ["split-window", "-v", "-l", "5", "-d", "-P", "-F", "#{pane_id}", "tail", "-f", this.logPath], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        this.paneId = output.trim();
+      } catch {
+        this.paneId = null;
+      }
+    }
+    cleanup() {
+      if (this.paneId) {
+        try {
+          execFileSync("tmux", ["kill-pane", "-t", this.paneId], {
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+        } catch {}
+        this.paneId = null;
+      }
+      super.cleanup();
+    }
+  };
 });
 
 // src/port-manager.ts
@@ -101360,8 +102427,10 @@ class OpenRouterProvider {
   streamFormat = "openai-sse";
   apiKey;
   queue;
-  constructor(apiKey) {
+  modelId;
+  constructor(apiKey, modelId) {
     this.apiKey = apiKey;
+    this.modelId = modelId || "";
     this.queue = OpenRouterRequestQueue.getInstance();
   }
   overrideStreamFormat() {
@@ -101380,10 +102449,16 @@ class OpenRouterProvider {
   async enqueueRequest(fetchFn) {
     return this.queue.enqueue(fetchFn);
   }
+  getContextWindow() {
+    const models = this.modelId ? getCachedOpenRouterModels() : null;
+    const model = models?.find((m2) => m2.id === this.modelId);
+    return model?.context_length || model?.top_provider?.context_length || 200000;
+  }
 }
 var OPENROUTER_API_URL2 = "https://openrouter.ai/api/v1/chat/completions";
 var init_openrouter2 = __esm(() => {
   init_openrouter_queue();
+  init_model_loader();
 });
 
 // src/adapters/openrouter-adapter.ts
@@ -102349,9 +103424,9 @@ var init_middleware = __esm(() => {
 });
 
 // src/handlers/shared/token-tracker.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
-import { homedir as homedir16 } from "os";
-import { join as join18 } from "path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir18 } from "os";
+import { join as join21 } from "path";
 
 class TokenTracker {
   port;
@@ -102465,9 +103540,9 @@ class TokenTracker {
         is_free: isFreeModel,
         is_estimated: isEstimate || false
       };
-      const claudishDir = join18(homedir16(), ".claudish");
-      mkdirSync10(claudishDir, { recursive: true });
-      writeFileSync11(join18(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+      const claudishDir = join21(homedir18(), ".claudish");
+      mkdirSync12(claudishDir, { recursive: true });
+      writeFileSync13(join21(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -103519,9 +104594,9 @@ class ComposedHandler {
         });
         return c.json({ error: { type: "connection_error", message: err.message } }, 503);
       }
-      if (this.provider.getContextWindow) {
-        this.tokenTracker.setContextWindow(this.provider.getContextWindow());
-      }
+    }
+    if (this.provider.getContextWindow) {
+      this.tokenTracker.setContextWindow(this.provider.getContextWindow());
     }
     if (this.provider.transformPayload) {
       requestPayload = this.provider.transformPayload(requestPayload);
@@ -103888,9 +104963,9 @@ var init_composed_handler = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync12, existsSync as existsSync18, mkdirSync as mkdirSync11, statSync } from "fs";
-import { homedir as homedir17 } from "os";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync14, existsSync as existsSync19, mkdirSync as mkdirSync13, statSync as statSync2 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join22 } from "path";
 function getDynamicPricingSync(provider, modelName) {
   if (provider === "openrouter") {
     const direct = pricingMap.get(modelName);
@@ -103955,12 +105030,12 @@ async function warmPricingCache() {
 }
 function loadDiskCache() {
   try {
-    if (!existsSync18(CACHE_FILE))
+    if (!existsSync19(CACHE_FILE))
       return false;
-    const stat = statSync(CACHE_FILE);
+    const stat = statSync2(CACHE_FILE);
     const age = Date.now() - stat.mtimeMs;
     const isFresh = age < CACHE_TTL_MS;
-    const raw2 = readFileSync15(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync17(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -103972,12 +105047,12 @@ function loadDiskCache() {
 }
 function saveDiskCache() {
   try {
-    mkdirSync11(CACHE_DIR, { recursive: true });
+    mkdirSync13(CACHE_DIR, { recursive: true });
     const data = {};
     for (const [key, pricing] of pricingMap) {
       data[key] = pricing;
     }
-    writeFileSync12(CACHE_FILE, JSON.stringify(data), "utf-8");
+    writeFileSync14(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch (error46) {
     log(`[PricingCache] Error saving disk cache: ${error46}`);
   }
@@ -104007,8 +105082,8 @@ var init_pricing_cache = __esm(() => {
   init_model_loader();
   init_remote_provider_types();
   pricingMap = new Map;
-  CACHE_DIR = join19(homedir17(), ".claudish");
-  CACHE_FILE = join19(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join22(homedir19(), ".claudish");
+  CACHE_FILE = join22(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   PROVIDER_TO_OR_PREFIX = {
     openai: ["openai/"],
@@ -104467,12 +105542,12 @@ class AnthropicCompatProvider {
     }
     if (this.provider.name === "kimi-coding" && !this.apiKey) {
       try {
-        const { existsSync: existsSync19, readFileSync: readFileSync16 } = await import("fs");
-        const { join: join20 } = await import("path");
-        const { homedir: homedir18 } = await import("os");
-        const credPath = join20(homedir18(), ".claudish", "kimi-oauth.json");
-        if (existsSync19(credPath)) {
-          const data = JSON.parse(readFileSync16(credPath, "utf-8"));
+        const { existsSync: existsSync20, readFileSync: readFileSync18 } = await import("fs");
+        const { join: join23 } = await import("path");
+        const { homedir: homedir20 } = await import("os");
+        const credPath = join23(homedir20(), ".claudish", "kimi-oauth.json");
+        if (existsSync20(credPath)) {
+          const data = JSON.parse(readFileSync18(credPath, "utf-8"));
           if (data.access_token && data.refresh_token) {
             const { KimiOAuth: KimiOAuth2 } = await Promise.resolve().then(() => (init_kimi_oauth(), exports_kimi_oauth));
             const oauth = KimiOAuth2.getInstance();
@@ -104589,12 +105664,18 @@ var init_anthropic_passthrough_adapter = __esm(() => {
       if (model.includes("kimi-k2.5") || model.includes("kimi-k2-5"))
         return 262144;
       if (model.includes("kimi-k2"))
-        return 262144;
+        return 131000;
       if (this.providerName === "kimi" || this.providerName === "kimi-coding" || model.includes("kimi")) {
         return 131072;
       }
+      if (model.includes("minimax-01") || model.includes("minimax-m1"))
+        return 1e6;
+      if (model.includes("minimax-m2.7"))
+        return 204800;
+      if (model.includes("minimax-m2"))
+        return 196608;
       if (this.providerName === "minimax" || this.providerName === "minimax-coding") {
-        return 1e5;
+        return 196608;
       }
       return 128000;
     }
@@ -104775,10 +105856,10 @@ var init_litellm2 = __esm(() => {
 });
 
 // src/adapters/litellm-adapter.ts
-import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
 import { createHash as createHash5 } from "crypto";
-import { homedir as homedir18 } from "os";
-import { join as join20 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join23 } from "path";
 var INLINE_IMAGE_MODEL_PATTERNS, LiteLLMAdapter;
 var init_litellm_adapter = __esm(() => {
   init_base_adapter();
@@ -104874,10 +105955,10 @@ var init_litellm_adapter = __esm(() => {
     checkVisionSupport() {
       try {
         const hash2 = createHash5("sha256").update(this.baseUrl).digest("hex").substring(0, 16);
-        const cachePath = join20(homedir18(), ".claudish", `litellm-models-${hash2}.json`);
-        if (!existsSync19(cachePath))
+        const cachePath = join23(homedir20(), ".claudish", `litellm-models-${hash2}.json`);
+        if (!existsSync20(cachePath))
           return true;
-        const cacheData = JSON.parse(readFileSync16(cachePath, "utf-8"));
+        const cacheData = JSON.parse(readFileSync18(cachePath, "utf-8"));
         const model = cacheData.models?.find((m2) => m2.name === this.modelId);
         if (model && model.supportsVision === false) {
           log(`[LiteLLMAdapter] Model ${this.modelId} does not support vision`);
@@ -104894,9 +105975,9 @@ var init_litellm_adapter = __esm(() => {
 // src/auth/vertex-auth.ts
 import { exec as exec4 } from "child_process";
 import { promisify as promisify3 } from "util";
-import { existsSync as existsSync20 } from "fs";
-import { homedir as homedir19 } from "os";
-import { join as join21 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { homedir as homedir21 } from "os";
+import { join as join24 } from "path";
 
 class VertexAuthManager {
   cachedToken = null;
@@ -104950,8 +106031,8 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join21(homedir19(), ".config/gcloud/application_default_credentials.json");
-      if (!existsSync20(adcPath)) {
+      const adcPath = join24(homedir21(), ".config/gcloud/application_default_credentials.json");
+      if (!existsSync21(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
       }
@@ -104975,7 +106056,7 @@ class VertexAuthManager {
     if (!credPath) {
       return null;
     }
-    if (!existsSync20(credPath)) {
+    if (!existsSync21(credPath)) {
       throw new Error(`Service account file not found: ${credPath}
 
 Check GOOGLE_APPLICATION_CREDENTIALS path.`);
@@ -105014,8 +106095,8 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join21(homedir19(), ".config/gcloud/application_default_credentials.json");
-  const hasADC = existsSync20(adcPath);
+  const adcPath = join24(homedir21(), ".config/gcloud/application_default_credentials.json");
+  const hasADC = existsSync21(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
     return `No Vertex AI credentials found.
@@ -105343,7 +106424,7 @@ async function createProxyServer(port, openrouterApiKey, model, monitorMode = fa
     const parsed = parseModelSpec(targetModel);
     const modelId = targetModel.includes("@") ? parsed.model : targetModel;
     if (!openRouterHandlers.has(modelId)) {
-      const orProvider = new OpenRouterProvider(openrouterApiKey || "");
+      const orProvider = new OpenRouterProvider(openrouterApiKey || "", modelId);
       const orAdapter = new OpenRouterAdapter(modelId);
       openRouterHandlers.set(modelId, new ComposedHandler(orProvider, modelId, modelId, port, {
         adapter: orAdapter,
@@ -105651,16 +106732,16 @@ var init_proxy_server = __esm(() => {
 
 // src/index.ts
 var import_dotenv2 = __toESM(require_main(), 1);
-import { existsSync as existsSync21, readFileSync as readFileSync18 } from "fs";
-import { homedir as homedir20 } from "os";
-import { join as join22 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
+import { homedir as homedir22 } from "os";
+import { join as join25 } from "path";
 import_dotenv2.config({ quiet: true });
 function loadStoredApiKeys() {
   try {
-    const configPath = join22(homedir20(), ".claudish", "config.json");
-    if (!existsSync21(configPath))
+    const configPath = join25(homedir22(), ".claudish", "config.json");
+    if (!existsSync23(configPath))
       return;
-    const raw2 = readFileSync18(configPath, "utf-8");
+    const raw2 = readFileSync20(configPath, "utf-8");
     const cfg = JSON.parse(raw2);
     if (cfg.apiKeys) {
       for (const [envVar, value] of Object.entries(cfg.apiKeys)) {
@@ -105698,6 +106779,7 @@ var isProfileCommand = args[0] === "profile" || args.some((a, i) => a === "profi
 var isTelemetryCommand = args[0] === "telemetry";
 var isStatsCommand = args[0] === "stats";
 var isConfigCommand = args[0] === "config";
+var isTeamCommand = args[0] === "team";
 if (isMcpMode) {
   Promise.resolve().then(() => (init_mcp_server(), exports_mcp_server)).then((mcp) => mcp.startMcpServer());
 } else if (isGeminiLogin) {
@@ -105776,6 +106858,8 @@ if (isMcpMode) {
   });
 } else if (isConfigCommand) {
   init_tui().then(() => exports_tui).then((m2) => m2.startConfigTui().catch(handlePromptExit));
+} else if (isTeamCommand) {
+  Promise.resolve().then(() => (init_team_cli(), exports_team_cli)).then((m2) => m2.teamCommand(args.slice(1)));
 } else {
   runCli();
 }
@@ -105790,7 +106874,8 @@ async function runCli() {
     getMissingKeyResolutions: getMissingKeyResolutions2,
     getMissingKeysError: getMissingKeysError2
   } = await Promise.resolve().then(() => (init_provider_resolver(), exports_provider_resolver));
-  const { initLogger: initLogger2, getLogFilePath: getLogFilePath2, setStderrQuiet: setStderrQuiet2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
+  const { initLogger: initLogger2, getLogFilePath: getLogFilePath2, getAlwaysOnLogPath: getAlwaysOnLogPath2, setDiagOutput: setDiagOutput2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
+  const { createDiagOutput: createDiagOutput2, LogFileDiagOutput: LogFileDiagOutput2 } = await Promise.resolve().then(() => (init_diag_output(), exports_diag_output));
   const { findAvailablePort: findAvailablePort2 } = await Promise.resolve().then(() => (init_port_manager(), exports_port_manager));
   const { createProxyServer: createProxyServer2 } = await Promise.resolve().then(() => (init_proxy_server(), exports_proxy_server));
   const { checkForUpdates: checkForUpdates2 } = await Promise.resolve().then(() => (init_update_checker(), exports_update_checker));
@@ -105803,7 +106888,7 @@ async function runCli() {
   }
   try {
     const cliConfig = await parseArgs2(process.argv.slice(2));
-    initLogger2(cliConfig.debug, cliConfig.logLevel);
+    initLogger2(cliConfig.debug, cliConfig.logLevel, cliConfig.noLogs);
     const { initTelemetry: initTelemetry2 } = await Promise.resolve().then(() => (init_telemetry(), exports_telemetry));
     initTelemetry2(cliConfig);
     const { initStats: initStats2, showMonthlyBanner: showMonthlyBanner2 } = await Promise.resolve().then(() => (init_stats(), exports_stats));
@@ -105908,14 +106993,19 @@ async function runCli() {
       quiet: cliConfig.quiet,
       isInteractive: cliConfig.interactive
     });
+    const diag = createDiagOutput2({ interactive: cliConfig.interactive });
     if (cliConfig.interactive) {
-      setStderrQuiet2(true);
+      setDiagOutput2(diag);
+      if (!process.env.TMUX && !cliConfig.quiet && diag instanceof LogFileDiagOutput2) {
+        console.log(`[claudish] Diagnostic log: ${diag.getLogPath()}`);
+      }
     }
     let exitCode = 0;
     try {
-      exitCode = await runClaudeWithProxy2(cliConfig, proxy.url);
+      exitCode = await runClaudeWithProxy2(cliConfig, proxy.url, () => diag.cleanup());
     } finally {
-      setStderrQuiet2(false);
+      setDiagOutput2(null);
+      diag.cleanup();
       if (!cliConfig.quiet) {
         console.log(`
 [claudish] Shutting down proxy server...`);
@@ -105926,6 +107016,12 @@ async function runCli() {
       console.log(`[claudish] Done
 `);
     }
+    const sessionLogPath = getAlwaysOnLogPath2();
+    if (exitCode !== 0 && sessionLogPath && !cliConfig.quiet) {
+      console.error(`
+[claudish] Session ended with errors. Log: ${sessionLogPath}`);
+      console.error(`[claudish] To review: /debug-logs ${sessionLogPath}`);
+    }
     process.exit(exitCode);
   } catch (error46) {
     console.error("[claudish] Fatal error:", error46);