claudish 5.14.0 → 5.15.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,19 +29145,21 @@ 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,
   maskCredential: () => maskCredential,
@@ -28719,10 +29169,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 +29186,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 +29206,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,6 +29317,13 @@ 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);
   }
@@ -28801,8 +29341,11 @@ function setStderrQuiet(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 +29392,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, 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 +29417,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 +29442,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 +29464,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 +29541,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 +29560,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 +29596,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 +29659,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 +29875,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 +29902,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 +29942,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 +30020,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 +30070,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 +30092,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 +30159,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 +30176,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 +30195,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 +30219,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 +30285,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 +30360,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 +30383,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 +30421,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 +30492,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 +30536,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 +30577,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 +30782,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",
@@ -30464,18 +31017,18 @@ var init_model_parser = __esm(() => {
 });
 
 // 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 +31108,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 +31155,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 +31175,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 +31212,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 +31228,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 +31290,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;
@@ -30858,11 +31411,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,10 +31442,10 @@ 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];
@@ -31489,9 +32042,9 @@ __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 isApiKeyAvailable(info) {
   if (!info.envVar) {
     return true;
@@ -31508,8 +32061,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 {}
@@ -32421,6 +32974,8 @@ var init_grok_adapter = __esm(() => {
     }
     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,7 +34221,7 @@ CRITICAL INSTRUCTION FOR OUTPUT FORMAT:
       this.reasoningBlockDepth = 0;
     }
     getContextWindow() {
-      return 1e6;
+      return 1048576;
     }
     shouldHandle(modelId) {
       return modelId.includes("gemini") || modelId.includes("google/");
@@ -33886,9 +34441,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;
@@ -34068,18 +34625,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]
@@ -34121,6 +34680,43 @@ 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) {
+      const lower = modelId.toLowerCase();
+      return lower.includes("xiaomi") || lower.includes("mimo");
+    }
+    getName() {
+      return "XiaomiAdapter";
+    }
+  };
+});
+
 // src/adapters/adapter-manager.ts
 var exports_adapter_manager = {};
 __export(exports_adapter_manager, {
@@ -34139,7 +34735,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 +34762,7 @@ var init_adapter_manager = __esm(() => {
   init_minimax_adapter();
   init_deepseek_adapter();
   init_glm_adapter();
+  init_xiaomi_adapter();
 });
 
 // src/cli.ts
@@ -34181,31 +34779,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 +34827,7 @@ async function parseArgs(args) {
     monitor: false,
     stdin: false,
     freeOnly: false,
+    noLogs: false,
     claudeArgs: []
   };
   const claudishModel = process.env[ENV.CLAUDISH_MODEL];
@@ -34395,6 +34994,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 +35097,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 +35116,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 +35267,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 +35289,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 +35470,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 +35554,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 +35567,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 +35586,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 +35894,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 +36146,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 +36163,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 +36184,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 +36235,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 +36286,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 +36373,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.15.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 +36385,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 +36403,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 +36417,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 +36450,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 +36460,8 @@ function isCacheValid(cache) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync13(cachePath)) {
-      unlinkSync4(cachePath);
+    if (existsSync14(cachePath)) {
+      unlinkSync5(cachePath);
     }
   } catch {}
 }
@@ -35895,7 +36497,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 +36505,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 +36616,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 +36624,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 +38310,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 +38353,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 +38380,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 +38941,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 +38961,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 +38979,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 +39465,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 +40070,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 +40930,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 +41118,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 +41160,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 +41205,8 @@ function clearBuffer() {
   try {
     memoryCache = [];
     eventsSinceLastFlush = 0;
-    if (existsSync15(BUFFER_FILE)) {
-      unlinkSync5(BUFFER_FILE);
+    if (existsSync16(BUFFER_FILE)) {
+      unlinkSync6(BUFFER_FILE);
     }
   } catch {}
 }
@@ -40632,8 +41234,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 +41720,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 +44065,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 +44101,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 +44123,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 +47075,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 +54319,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 +54385,7 @@ var init_index_0wbvecnk = __esm(async () => {
         return normalizeBunfsPath(parse6(path2).base);
       }
       if (!isAbsolute(path2)) {
-        return resolve2(path2);
+        return resolve22(path2);
       }
       return path2;
     }
@@ -98429,24 +99031,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 +99267,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 +99300,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 +99314,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}`);
@@ -98636,14 +99377,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,14 +99406,14 @@ 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
@@ -98679,7 +99425,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     });
   });
   try {
-    unlinkSync6(tempSettingsPath);
+    unlinkSync7(tempSettingsPath);
   } catch (error46) {}
   return exitCode;
 }
@@ -98693,7 +99439,7 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet) {
       }
       proc.kill();
       try {
-        unlinkSync6(tempSettingsPath);
+        unlinkSync7(tempSettingsPath);
       } catch {}
       process.exit(0);
     });
@@ -98702,23 +99448,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 +99472,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 +99518,7 @@ async function checkClaudeInstalled() {
 }
 var init_claude_runner = __esm(() => {
   init_config();
+  init_model_parser();
 });
 
 // src/port-manager.ts
@@ -101360,8 +102107,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 +102129,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 +103104,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 mkdirSync11, writeFileSync as writeFileSync12 } from "fs";
+import { homedir as homedir17 } from "os";
+import { join as join20 } from "path";
 
 class TokenTracker {
   port;
@@ -102465,9 +103220,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 = join20(homedir17(), ".claudish");
+      mkdirSync11(claudishDir, { recursive: true });
+      writeFileSync12(join20(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -103519,9 +104274,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 +104643,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 writeFileSync13, existsSync as existsSync19, mkdirSync as mkdirSync12, statSync as statSync2 } from "fs";
+import { homedir as homedir18 } from "os";
+import { join as join21 } from "path";
 function getDynamicPricingSync(provider, modelName) {
   if (provider === "openrouter") {
     const direct = pricingMap.get(modelName);
@@ -103955,12 +104710,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 +104727,12 @@ function loadDiskCache() {
 }
 function saveDiskCache() {
   try {
-    mkdirSync11(CACHE_DIR, { recursive: true });
+    mkdirSync12(CACHE_DIR, { recursive: true });
     const data = {};
     for (const [key, pricing] of pricingMap) {
       data[key] = pricing;
     }
-    writeFileSync12(CACHE_FILE, JSON.stringify(data), "utf-8");
+    writeFileSync13(CACHE_FILE, JSON.stringify(data), "utf-8");
   } catch (error46) {
     log(`[PricingCache] Error saving disk cache: ${error46}`);
   }
@@ -104007,8 +104762,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 = join21(homedir18(), ".claudish");
+  CACHE_FILE = join21(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS = 24 * 60 * 60 * 1000;
   PROVIDER_TO_OR_PREFIX = {
     openai: ["openai/"],
@@ -104467,12 +105222,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: join22 } = await import("path");
+        const { homedir: homedir19 } = await import("os");
+        const credPath = join22(homedir19(), ".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 +105344,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 +105536,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 homedir19 } from "os";
+import { join as join22 } from "path";
 var INLINE_IMAGE_MODEL_PATTERNS, LiteLLMAdapter;
 var init_litellm_adapter = __esm(() => {
   init_base_adapter();
@@ -104874,10 +105635,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 = join22(homedir19(), ".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 +105655,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 homedir20 } from "os";
+import { join as join23 } from "path";
 
 class VertexAuthManager {
   cachedToken = null;
@@ -104950,8 +105711,8 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join21(homedir19(), ".config/gcloud/application_default_credentials.json");
-      if (!existsSync20(adcPath)) {
+      const adcPath = join23(homedir20(), ".config/gcloud/application_default_credentials.json");
+      if (!existsSync21(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
       }
@@ -104975,7 +105736,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 +105775,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 = join23(homedir20(), ".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 +106104,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 +106412,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 homedir21 } from "os";
+import { join as join24 } from "path";
 import_dotenv2.config({ quiet: true });
 function loadStoredApiKeys() {
   try {
-    const configPath = join22(homedir20(), ".claudish", "config.json");
-    if (!existsSync21(configPath))
+    const configPath = join24(homedir21(), ".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 +106459,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 +106538,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 +106554,7 @@ 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, setStderrQuiet: setStderrQuiet2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
   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 +106567,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));
@@ -105926,6 +106690,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);