claudish 7.60.0 → 7.61.0

package/dist/index.js

@@ -729,7 +729,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.60.0";
+var VERSION = "7.61.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -5358,6 +5358,57 @@ var init_op_source = __esm(() => {
   environmentResolutions = new Map;
 });
 
+// src/classifier-passthrough.ts
+function blockText(block) {
+  if (typeof block === "string")
+    return block;
+  if (block && typeof block === "object" && block.type === "text" && typeof block.text === "string") {
+    return block.text;
+  }
+  return null;
+}
+function startsWithMarker(text) {
+  let i = 0;
+  while (i < text.length) {
+    const ch = text.charCodeAt(i);
+    if (ch !== 32 && ch !== 9 && ch !== 10 && ch !== 13 && ch !== 12 && ch !== 11)
+      break;
+    i++;
+  }
+  return text.startsWith(CLASSIFIER_SYSTEM_MARKER, i);
+}
+function isAutoModeClassifierRequest(body) {
+  if (!body || typeof body !== "object")
+    return false;
+  const system = body.system;
+  if (typeof system === "string")
+    return startsWithMarker(system);
+  if (!Array.isArray(system))
+    return false;
+  for (const block of system) {
+    const text = blockText(block);
+    if (text !== null && startsWithMarker(text))
+      return true;
+  }
+  return false;
+}
+function rewriteClassifierForNative(body, model) {
+  body.model = model;
+  delete body.thinking;
+}
+function resolveClassifierConfig(config, env = process.env) {
+  const flagModel = config.classifierModel?.trim();
+  const flagProvider = config.classifierProvider?.trim().toLowerCase();
+  const envProvider = env.CLAUDISH_CLASSIFIER_PROVIDER?.trim().toLowerCase();
+  const envModel = env.CLAUDISH_CLASSIFIER_MODEL?.trim();
+  const enabled = !!flagModel || flagProvider === "anthropic" || envProvider === "anthropic" || !!envModel;
+  return { enabled, model: flagModel || envModel || DEFAULT_CLASSIFIER_MODEL };
+}
+function classifierPassthroughEnabled(config, env = process.env) {
+  return resolveClassifierConfig(config, env).enabled;
+}
+var CLASSIFIER_SYSTEM_MARKER = "You are a security monitor for autonomous AI coding agents.", DEFAULT_CLASSIFIER_MODEL = "claude-sonnet-5";
+
 // src/onepassword-command.ts
 var exports_onepassword_command = {};
 __export(exports_onepassword_command, {
@@ -31653,6 +31704,8 @@ var init_qwen_model_dialect = __esm(() => {
       }
       if (originalRequest.thinking)
         delete request.thinking;
+      if (request.reasoning_effort !== undefined)
+        delete request.reasoning_effort;
       return request;
     }
     shouldHandle(modelId) {
@@ -37046,6 +37099,9 @@ function hasModelUnsupportedWording(errorBody) {
   const lower = (errorBody || "").toLowerCase();
   return UNSUPPORTED_PHRASES.some((phrase) => lower.includes(phrase));
 }
+function hasActionableLink(errorBody) {
+  return /https?:\/\/\S+/i.test(errorBody || "");
+}
 var UNSUPPORTED_PHRASES;
 var init_model_unsupported = __esm(() => {
   UNSUPPORTED_PHRASES = [
@@ -39256,7 +39312,7 @@ class ComposedHandler {
       }
     }
     if (this.provider.transformPayload) {
-      requestPayload = this.provider.transformPayload(requestPayload);
+      requestPayload = this.provider.transformPayload(requestPayload, claudeRequest);
     }
     const endpoint = this.provider.getEndpoint(this.targetModel);
     const headers = await this.provider.getHeaders();
@@ -39899,6 +39955,9 @@ function getRecoveryHint(status, errorText, providerName, transportTerminal429)
     if (isQuotaExhaustionError(status, errorText)) {
       return "Out of quota \u2014 check your plan & billing details. This won't recover on retry.";
     }
+    if (hasActionableLink(errorText)) {
+      return "Provider rejected the request and gave a specific fix \u2014 follow the link in the message below.";
+    }
     return "Check API key / OAuth credentials.";
   }
   if (status === 404) {
@@ -43669,14 +43728,19 @@ var init_ollamacloud = __esm(() => {
 });
 
 // src/providers/transport/openai-codex.ts
-var OpenAICodexTransport;
+import { createHash as createHash5, randomBytes as randomBytes6 } from "crypto";
+var FALLBACK_CONVERSATION_KEY, OpenAICodexTransport;
 var init_openai_codex = __esm(() => {
   init_codex_api_format();
   init_model_catalog();
   init_authority();
+  init_harness();
   init_openai();
+  FALLBACK_CONVERSATION_KEY = randomBytes6(16).toString("hex");
   OpenAICodexTransport = class OpenAICodexTransport extends OpenAIProviderTransport {
     cachedAuth = null;
+    cachedCacheKeyFor;
+    cachedCacheKey = "";
     async refreshAuth() {
       try {
         this.cachedAuth = await credentials.getRequestAuth("openai-codex", { model: "" });
@@ -43692,7 +43756,7 @@ var init_openai_codex = __esm(() => {
         return { ...this.cachedAuth.headers };
       return super.getHeaders();
     }
-    transformPayload(payload) {
+    transformPayload(payload, claudeRequest) {
       let normalizedPayload = payload;
       if (payload?.model) {
         const normalized = normalizeCodexModel(payload.model);
@@ -43700,8 +43764,24 @@ var init_openai_codex = __esm(() => {
           normalizedPayload = { ...payload, model: normalized };
         }
       }
+      if (normalizedPayload && typeof normalizedPayload === "object") {
+        normalizedPayload = {
+          ...normalizedPayload,
+          prompt_cache_key: normalizedPayload.prompt_cache_key ?? this.resolvePromptCacheKey(claudeRequest)
+        };
+      }
       return this.cachedAuth?.transformPayload?.(normalizedPayload) ?? normalizedPayload;
     }
+    resolvePromptCacheKey(claudeRequest) {
+      const sessionId2 = extractSessionId(claudeRequest);
+      if (!sessionId2)
+        return `claudish_${FALLBACK_CONVERSATION_KEY}`;
+      if (this.cachedCacheKeyFor !== sessionId2) {
+        this.cachedCacheKeyFor = sessionId2;
+        this.cachedCacheKey = `claudish_${createHash5("sha256").update(sessionId2).digest("hex").slice(0, 32)}`;
+      }
+      return this.cachedCacheKey;
+    }
     getContextWindow() {
       return lookupModelForProvider(this.modelName, this.name) ?? 0;
     }
@@ -44522,6 +44602,7 @@ var init_provider_definitions = __esm(() => {
       baseUrl: "https://api.z.ai",
       baseUrlEnvVars: ["ZHIPU_BASE_URL", "GLM_BASE_URL"],
       apiPath: "/api/paas/v4/chat/completions",
+      modelDiscovery: { path: "/api/paas/v4/models", format: "openai-models-list" },
       apiKeyEnvVar: "ZHIPU_API_KEY",
       apiKeyAliases: ["GLM_API_KEY"],
       apiKeyDescription: "GLM/Zhipu API Key",
@@ -48075,6 +48156,14 @@ function classifyHttpError(status, body, latencyMs) {
         errorMessage: extractErrorMessage(body) || `HTTP ${authStatus}`
       };
     }
+    if (hasActionableLink(body)) {
+      return {
+        state: "error",
+        latencyMs,
+        httpStatus: authStatus,
+        errorMessage: extractErrorMessage(body) || `HTTP ${authStatus}`
+      };
+    }
     return {
       state: "auth-failed",
       latencyMs,
@@ -48121,6 +48210,20 @@ function classifyHttpError(status, body, latencyMs) {
     errorMessage: extractErrorMessage(body) || `HTTP ${status}`
   };
 }
+function truncateKeepingLink(text, max = 160) {
+  if (text.length <= max)
+    return text;
+  const url2 = text.match(/https?:\/\/\S+/i)?.[0];
+  if (!url2)
+    return `${text.slice(0, max - 3)}...`;
+  const room = max - url2.length - 4;
+  if (room <= 0)
+    return url2;
+  const head = text.slice(0, room);
+  const lastSpace = head.lastIndexOf(" ");
+  const prose = (lastSpace > room * 0.5 ? head.slice(0, lastSpace) : head).trimEnd();
+  return `${prose}... ${url2}`;
+}
 function extractErrorMessage(body) {
   if (!body)
     return;
@@ -48128,13 +48231,13 @@ function extractErrorMessage(body) {
     const parsed = JSON.parse(body);
     const msg2 = parsed?.error?.message || parsed?.error?.error?.message || parsed?.message || parsed?.detail;
     if (typeof msg2 === "string" && msg2.length > 0) {
-      return msg2.length > 160 ? `${msg2.slice(0, 157)}...` : msg2;
+      return truncateKeepingLink(msg2);
     }
   } catch {}
   const trimmed2 = body.trim();
   if (!trimmed2)
     return;
-  return trimmed2.length > 160 ? `${trimmed2.slice(0, 157)}...` : trimmed2;
+  return truncateKeepingLink(trimmed2);
 }
 async function consumeProbeStream(response, timeoutMs, startedAt) {
   const body = response.body;
@@ -51893,6 +51996,41 @@ var exports_proxy_server = {};
 __export(exports_proxy_server, {
   createProxyServer: () => createProxyServer
 });
+import { appendFileSync as appendFileSync7, mkdirSync as mkdirSync13 } from "fs";
+import { join as join29 } from "path";
+function maybeCaptureClassifierRequest(c, body) {
+  if (!process.env.CLAUDISH_CLASSIFIER_DEBUG)
+    return;
+  try {
+    const dir = join29(process.cwd(), "logs");
+    if (!classifierCaptureDirReady) {
+      mkdirSync13(dir, { recursive: true });
+      classifierCaptureDirReady = true;
+    }
+    const record4 = {
+      ts: new Date().toISOString(),
+      model: body?.model,
+      stream: body?.stream,
+      max_tokens: body?.max_tokens,
+      temperature: body?.temperature,
+      top_p: body?.top_p,
+      top_k: body?.top_k,
+      thinking: body?.thinking,
+      hasTools: Array.isArray(body?.tools) && body.tools.length > 0,
+      tool_choice: body?.tool_choice,
+      system: body?.system,
+      headers: {
+        "anthropic-beta": c.req.header("anthropic-beta") ?? null,
+        "anthropic-version": c.req.header("anthropic-version") ?? null,
+        "x-app": c.req.header("x-app") ?? null,
+        authorization: c.req.header("authorization") ? "Bearer <present>" : null,
+        "x-api-key": c.req.header("x-api-key") ? "<present>" : null
+      }
+    };
+    appendFileSync7(join29(dir, "classifier-capture.jsonl"), `${JSON.stringify(record4)}
+`);
+  } catch {}
+}
 async function createProxyServer(port, _openrouterApiKey, model, monitorMode = false, anthropicApiKey, modelMap, options = {}) {
   try {
     const config2 = loadConfig();
@@ -52304,6 +52442,12 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
     try {
       const body = await c.req.json();
       log(`[RequestMeta] model=${body.model} output_config=${JSON.stringify(body.output_config) ?? "(none)"} metadata=${JSON.stringify(body.metadata) ?? "(none)"} anthropic-beta=${c.req.header("anthropic-beta") ?? "(none)"}`);
+      maybeCaptureClassifierRequest(c, body);
+      if (!monitorMode && options.classifier?.enabled && isAutoModeClassifierRequest(body)) {
+        log(`[Classifier] auto-mode permission classifier \u2192 native Anthropic (model ${body.model} \u2192 ${options.classifier.model})`);
+        rewriteClassifierForNative(body, options.classifier.model);
+        return nativeHandler.handle(c, body);
+      }
       const handler = await getHandlerForRequest(body.model);
       return await handler.handle(c, body);
     } catch (e) {
@@ -52349,7 +52493,7 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
     }
   };
 }
-var RoutingError;
+var RoutingError, classifierCaptureDirReady = false;
 var init_proxy_server = __esm(() => {
   init_dist();
   init_cors();
@@ -52429,12 +52573,12 @@ var init_redact = __esm(() => {
 
 // src/team-stats.ts
 import { existsSync as existsSync20, readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 function statsDir(sessionPath) {
-  return join29(sessionPath, "stats");
+  return join30(sessionPath, "stats");
 }
 function tokenFileFor(sessionPath, anonId) {
-  return join29(statsDir(sessionPath), `${anonId}.json`);
+  return join30(statsDir(sessionPath), `${anonId}.json`);
 }
 function readTokenStats(sessionPath, anonId) {
   const path = tokenFileFor(sessionPath, anonId);
@@ -52589,7 +52733,7 @@ ${segs.join(" \xB7 ")}`;
 }
 function writeStatusFile(sessionPath, manifest, status, opts) {
   try {
-    writeFileSync12(join29(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+    writeFileSync12(join30(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
 `, "utf-8");
   } catch {}
 }
@@ -52741,12 +52885,12 @@ import { spawn as spawn2 } from "child_process";
 import {
   createWriteStream as createWriteStream2,
   existsSync as existsSync21,
-  mkdirSync as mkdirSync13,
+  mkdirSync as mkdirSync14,
   readFileSync as readFileSync20,
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync13
 } from "fs";
-import { join as join30, resolve as resolve3 } from "path";
+import { join as join31, resolve as resolve3 } from "path";
 function resolveCaptureMode(explicit, env = process.env) {
   if (explicit)
     return explicit;
@@ -52843,18 +52987,18 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync21(join30(sessionPath, "manifest.json"))) {
+  if (existsSync21(join31(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. Use a new directory path or delete the existing session first.`);
   }
   const sentinels = models.filter(isSentinelModel);
   if (sentinels.length > 0) {
     throw new Error(`Invalid model(s) for team run: ${sentinels.join(", ")}. These are Claude Code agent selectors, not external model IDs. Use real external models (e.g., "gemini-2.0-flash", "gpt-4o", "or@deepseek/deepseek-r1"). For Claude models, use a Task agent instead of the team tool.`);
   }
-  mkdirSync13(join30(sessionPath, "work"), { recursive: true });
-  mkdirSync13(join30(sessionPath, "errors"), { recursive: true });
+  mkdirSync14(join31(sessionPath, "work"), { recursive: true });
+  mkdirSync14(join31(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync13(join30(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync21(join30(sessionPath, "input.md"))) {
+    writeFileSync13(join31(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync21(join31(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"));
@@ -52871,9 +53015,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync13(join30(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync14(join31(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync13(join30(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync13(join31(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -52887,7 +53031,7 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync13(join30(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync13(join31(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 function assertValidRequirePattern(pattern) {
@@ -52912,9 +53056,9 @@ function readFullOutputIfNeeded(opts) {
 async function runModels(sessionPath, opts = {}) {
   const timeoutMs = (opts.timeout ?? 300) * 1000;
   assertValidRequirePattern(opts.requirePattern);
-  const manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join30(sessionPath, "status.json");
-  const inputPath = join30(sessionPath, "input.md");
+  const manifest = JSON.parse(readFileSync20(join31(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join31(sessionPath, "status.json");
+  const inputPath = join31(sessionPath, "input.md");
   const inputContent = readFileSync20(inputPath, "utf-8");
   const spawnPlan = await (opts.spawnPlanner ?? prehydrateCredentialsForSpawn)(Object.values(manifest.models).map((m) => m.model));
   const statusCache = JSON.parse(readFileSync20(statusPath, "utf-8"));
@@ -52953,7 +53097,7 @@ async function runModels(sessionPath, opts = {}) {
       persistErrorLog(rt.errorLogPath, `RECOVERED: ${note}`, stderr, stdoutTail);
     opts.onStatusChange?.(id, statusCache.models[id]);
   }
-  mkdirSync13(statsDir(sessionPath), { recursive: true });
+  mkdirSync14(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
   const runtimes = new Map;
   const sigintHandler = () => {
@@ -52965,8 +53109,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join30(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join30(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join31(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join31(sessionPath, "errors", `${anonId}.log`);
     const spawnModel = spawnPlan.pinned.get(entry.model) ?? entry.model;
     const args = [
       "--model",
@@ -53192,7 +53336,7 @@ async function runModels(sessionPath, opts = {}) {
     opts.onStatusChange?.(id, statusCache.models[id]);
     const stopped = await terminateChildTree(proc);
     if (!stopped) {
-      persistErrorLog(rt?.errorLogPath ?? join30(sessionPath, "errors", `${id}.log`), "TIMEOUT: child survived SIGKILL \u2014 it may still be running and billing", stderr, stdoutTail);
+      persistErrorLog(rt?.errorLogPath ?? join31(sessionPath, "errors", `${id}.log`), "TIMEOUT: child survived SIGKILL \u2014 it may still be running and billing", stderr, stdoutTail);
     }
   };
   const allDone = Promise.all(completionPromises);
@@ -53251,23 +53395,23 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file2 of responseFiles) {
     const id = file2.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync20(join30(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync20(join31(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync20(join30(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync20(join31(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync13(join30(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync13(join31(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join30(sessionPath, "judging");
-  mkdirSync13(judgePath, { recursive: true });
+  const judgePath = join31(sessionPath, "judging");
+  mkdirSync14(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));
-  writeFileSync13(join30(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync13(join31(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync20(join30(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync20(join31(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -53277,7 +53421,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync20(join31(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -53340,7 +53484,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file2.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync20(join30(judgePath, file2), "utf-8");
+      content = readFileSync20(join31(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -53392,7 +53536,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync20(join30(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync20(join31(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -53453,9 +53597,9 @@ __export(exports_mcp_server, {
   parseAnthropicSse: () => parseAnthropicSse,
   formatTeamResult: () => formatTeamResult
 });
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync21, readdirSync as readdirSync4, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync15, readFileSync as readFileSync21, readdirSync as readdirSync4, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir29 } from "os";
-import { dirname as dirname9, join as join31, resolve as resolve4 } from "path";
+import { dirname as dirname9, join as join32, resolve as resolve4 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
   if (!forceRefresh && existsSync22(ALL_MODELS_CACHE_PATH2)) {
@@ -53474,7 +53618,7 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync14(CLAUDISH_CACHE_DIR, { recursive: true });
+    mkdirSync15(CLAUDISH_CACHE_DIR, { recursive: true });
     writeFileSync14(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
@@ -54194,16 +54338,16 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
         const sp = session_path;
         for (const file2 of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file2] = readFileSync21(join31(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync21(join32(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join31(sp, "errors");
+          const errorDir = join32(sp, "errors");
           if (existsSync22(errorDir)) {
             for (const f of readdirSync4(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync21(join31(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync21(join32(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -54213,7 +54357,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
           for (const f of readdirSync4(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync21(join31(sp, f), "utf-8");
+                const content = readFileSync21(join32(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -54222,7 +54366,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join31(__dirname2, "../package.json");
+        const pkgPath = join32(__dirname2, "../package.json");
         if (existsSync22(pkgPath)) {
           version2 = JSON.parse(readFileSync21(pkgPath, "utf-8")).version;
         }
@@ -54643,8 +54787,8 @@ var init_mcp_server = __esm(() => {
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
   __dirname2 = dirname9(__filename2);
-  CLAUDISH_CACHE_DIR = join31(homedir29(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join31(CLAUDISH_CACHE_DIR, "all-models.json");
+  CLAUDISH_CACHE_DIR = join32(homedir29(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join32(CLAUDISH_CACHE_DIR, "all-models.json");
   NEXT_STEP = {
     nonzero_exit: "read the evidence log, then retry or drop the model",
     timeout: "raise `timeout`, or pick a faster model",
@@ -54968,7 +55112,7 @@ import { spawn as spawn3 } from "child_process";
 import { execSync } from "child_process";
 import { existsSync as existsSync25, readFileSync as readFileSync24, writeFileSync as writeFileSync16 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname10, join as join32 } from "path";
+import { dirname as dirname10, join as join33 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveRouteInfo(modelId) {
@@ -55062,17 +55206,17 @@ function buildPaneHeader(model, prompt, bg) {
 function findMagmuxBinary() {
   const thisFile = fileURLToPath2(import.meta.url);
   const thisDir = dirname10(thisFile);
-  const pkgRoot = join32(thisDir, "..");
+  const pkgRoot = join33(thisDir, "..");
   const platform2 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join32(pkgRoot, "native", `magmux-${platform2}-${arch}`);
+  const bundledMagmux = join33(pkgRoot, "native", `magmux-${platform2}-${arch}`);
   if (existsSync25(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform2}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join32(searchDir, "node_modules", pkgName, "bin", "magmux");
+      const candidate = join33(searchDir, "node_modules", pkgName, "bin", "magmux");
       if (existsSync25(candidate))
         return candidate;
       const parent = dirname10(searchDir);
@@ -55184,9 +55328,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join32(sessionPath, "gridfile.txt");
-  const prompt = readFileSync24(join32(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync24(join32(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join33(sessionPath, "gridfile.txt");
+  const prompt = readFileSync24(join33(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync24(join33(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -55217,7 +55361,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join32(sessionPath, "status.json");
+  const statusPath = join33(sessionPath, "status.json");
   writeFileSync16(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
@@ -55243,7 +55387,7 @@ __export(exports_team_cli, {
   teamCommand: () => teamCommand
 });
 import { readFileSync as readFileSync25 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 function getFlag(args, flag) {
   const idx = args.indexOf(flag);
   if (idx === -1 || idx + 1 >= args.length)
@@ -55366,7 +55510,7 @@ async function teamCommand(args) {
     }
     case "judge": {
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync25(join33(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync25(join34(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -55384,7 +55528,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync25(join33(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync25(join34(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -67909,7 +68053,7 @@ var init_dist16 = __esm(() => {
 import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync26, unlinkSync as unlinkSync7 } from "fs";
 import { homedir as homedir30 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -68030,7 +68174,7 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join34(homedir30(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      const tokenFile = join35(homedir30(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
       if (existsSync26(tokenFile))
         unlinkSync7(tokenFile);
     } catch {}
@@ -68401,7 +68545,9 @@ var init_config2 = __esm(() => {
     CLAUDISH_SUMMARIZE_TOOLS: "CLAUDISH_SUMMARIZE_TOOLS",
     CLAUDISH_DIAG_MODE: "CLAUDISH_DIAG_MODE",
     CLAUDISH_DEBUG: "CLAUDISH_DEBUG",
-    CLAUDISH_ANTHROPIC_API_BILLING: "CLAUDISH_ANTHROPIC_API_BILLING"
+    CLAUDISH_ANTHROPIC_API_BILLING: "CLAUDISH_ANTHROPIC_API_BILLING",
+    CLAUDISH_CLASSIFIER_PROVIDER: "CLAUDISH_CLASSIFIER_PROVIDER",
+    CLAUDISH_CLASSIFIER_MODEL: "CLAUDISH_CLASSIFIER_MODEL"
   };
   OPENROUTER_HEADERS = {
     "HTTP-Referer": "https://claudish.com",
@@ -71785,20 +71931,20 @@ __export(exports_cli, {
 import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync27,
-  mkdirSync as mkdirSync15,
+  mkdirSync as mkdirSync16,
   readFileSync as readFileSync27,
   readdirSync as readdirSync5,
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync18
 } from "fs";
 import { homedir as homedir31 } from "os";
-import { dirname as dirname11, join as join35 } from "path";
+import { dirname as dirname11, join as join36 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join35(homedir31(), ".claudish");
+  const cacheDir = join36(homedir31(), ".claudish");
   if (!existsSync27(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
@@ -71807,7 +71953,7 @@ function clearAllModelCaches() {
     const files = readdirSync5(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync8(join35(cacheDir, file2));
+        unlinkSync8(join36(cacheDir, file2));
         cleared++;
       }
     }
@@ -72013,6 +72159,20 @@ async function parseArgs(args) {
       config3.defaultProvider = dpArg;
     } else if (arg === "--anthropic-api-billing") {
       config3.anthropicApiBilling = true;
+    } else if (arg === "--classifier-model") {
+      const cmArg = args[++i];
+      if (!cmArg) {
+        console.error("--classifier-model requires a model id");
+        process.exit(1);
+      }
+      config3.classifierModel = cmArg;
+    } else if (arg === "--classifier-provider") {
+      const cpArg = args[++i];
+      if (!cpArg) {
+        console.error("--classifier-provider requires a provider name (e.g. anthropic)");
+        process.exit(1);
+      }
+      config3.classifierProvider = cpArg;
     } else if (arg === "--op-env" || arg.startsWith("--op-env=")) {
       const v = arg.startsWith("--op-env=") ? arg.slice("--op-env=".length) : args[++i];
       if (!v) {
@@ -72223,14 +72383,14 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join35(homedir31(), ".claudish", ".legacy-litellm-hint-shown");
+      const markerFile = join36(homedir31(), ".claudish", ".legacy-litellm-hint-shown");
       if (!existsSync27(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
         }
         try {
-          mkdirSync15(dirname11(markerFile), { recursive: true });
+          mkdirSync16(dirname11(markerFile), { recursive: true });
           writeFileSync18(markerFile, new Date().toISOString(), "utf-8");
         } catch {}
       }
@@ -73333,7 +73493,7 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join35(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guidePath = join36(__dirname3, "../AI_AGENT_GUIDE.md");
     const guideContent = readFileSync27(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
@@ -73350,10 +73510,10 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join35(cwd, ".claude");
-  const skillsDir = join35(claudeDir, "skills");
-  const claudishSkillDir = join35(skillsDir, "claudish-usage");
-  const skillFile = join35(claudishSkillDir, "SKILL.md");
+  const claudeDir = join36(cwd, ".claude");
+  const skillsDir = join36(claudeDir, "skills");
+  const claudishSkillDir = join36(skillsDir, "claudish-usage");
+  const skillFile = join36(claudishSkillDir, "SKILL.md");
   if (existsSync27(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
@@ -73361,7 +73521,7 @@ async function initializeClaudishSkill() {
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join35(__dirname3, "../skills/claudish-usage/SKILL.md");
+  const sourceSkillPath = join36(__dirname3, "../skills/claudish-usage/SKILL.md");
   if (!existsSync27(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
@@ -73372,15 +73532,15 @@ async function initializeClaudishSkill() {
   }
   try {
     if (!existsSync27(claudeDir)) {
-      mkdirSync15(claudeDir, { recursive: true });
+      mkdirSync16(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
     if (!existsSync27(skillsDir)) {
-      mkdirSync15(skillsDir, { recursive: true });
+      mkdirSync16(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
     if (!existsSync27(claudishSkillDir)) {
-      mkdirSync15(claudishSkillDir, { recursive: true });
+      mkdirSync16(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync2(sourceSkillPath, skillFile);
@@ -73467,24 +73627,24 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync28, unlinkSync as unlinkSync9, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync28, unlinkSync as unlinkSync9, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir32, platform as platform2, tmpdir } from "os";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join36(homedir32(), "AppData", "Local");
-    cacheDir = join36(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join37(homedir32(), "AppData", "Local");
+    cacheDir = join37(localAppData, "claudish");
   } else {
-    cacheDir = join36(homedir32(), ".cache", "claudish");
+    cacheDir = join37(homedir32(), ".cache", "claudish");
   }
   try {
     if (!existsSync28(cacheDir)) {
-      mkdirSync16(cacheDir, { recursive: true });
+      mkdirSync17(cacheDir, { recursive: true });
     }
-    return join36(cacheDir, "update-check.json");
+    return join37(cacheDir, "update-check.json");
   } catch {
-    return join36(tmpdir(), "claudish-update-check.json");
+    return join37(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
@@ -74401,9 +74561,9 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync29, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync18, readFileSync as readFileSync29, writeFileSync as writeFileSync20 } from "fs";
 import { homedir as homedir33 } from "os";
-import { dirname as dirname12, join as join37 } from "path";
+import { dirname as dirname12, join as join38 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   if (!existsSync29(path2))
     return null;
@@ -74418,7 +74578,7 @@ function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   return raw2;
 }
 function writeProbeModelsCache(data, path2 = PROBE_MODELS_CACHE_PATH) {
-  mkdirSync17(dirname12(path2), { recursive: true });
+  mkdirSync18(dirname12(path2), { recursive: true });
   writeFileSync20(path2, JSON.stringify(data), "utf-8");
 }
 function isCacheFresh(data, ttlMs = CACHE_TTL_MS4) {
@@ -74538,7 +74698,7 @@ function isValidResponse(raw2) {
 var PROBE_MODELS_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/probeModels", CACHE_TTL_MS4, FETCH_TIMEOUT_MS3 = 15000, PROBE_MODELS_CACHE_PATH, _inFlight = null;
 var init_probe_catalog = __esm(() => {
   CACHE_TTL_MS4 = 60 * 60 * 1000;
-  PROBE_MODELS_CACHE_PATH = join37(homedir33(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join38(homedir33(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -80870,13 +81030,16 @@ var init_terminal_isolation = __esm(() => {
 // src/claude-runner.ts
 var exports_claude_runner = {};
 __export(exports_claude_runner, {
+  shouldHideIncidentalAnthropicKey: () => shouldHideIncidentalAnthropicKey,
   runClaudeWithProxy: () => runClaudeWithProxy,
   resolveLocalContextWindow: () => resolveLocalContextWindow,
   resolveContextWindowEnv: () => resolveContextWindowEnv,
   managedSettingsForcesClaudeAi: () => managedSettingsForcesClaudeAi,
   isProxyAuthMode: () => isProxyAuthMode,
   initializeTokenFile: () => initializeTokenFile,
+  hasResolvableAnthropicAuth: () => hasResolvableAnthropicAuth,
   discoverUserStatusLineCommand: () => discoverUserStatusLineCommand,
+  defaultKeychainAnthropicProbe: () => defaultKeychainAnthropicProbe,
   createTempSettingsFile: () => createTempSettingsFile,
   createStatusLineScript: () => createStatusLineScript,
   computeMainThreadContextWindow: () => computeMainThreadContextWindow,
@@ -80889,11 +81052,11 @@ __export(exports_claude_runner, {
   MIN_AUTO_COMPACT_WINDOW: () => MIN_AUTO_COMPACT_WINDOW,
   CLAUDE_CODE_DEFAULT_MAX_CONTEXT: () => CLAUDE_CODE_DEFAULT_MAX_CONTEXT
 });
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn5, spawnSync as spawnSync5 } from "child_process";
 import {
   closeSync as closeSync5,
   existsSync as existsSync30,
-  mkdirSync as mkdirSync18,
+  mkdirSync as mkdirSync19,
   openSync as openSync5,
   readFileSync as readFileSync30,
   readdirSync as readdirSync6,
@@ -80902,7 +81065,7 @@ import {
   writeFileSync as writeFileSync21
 } from "fs";
 import { homedir as homedir34, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname13, join as join38 } from "path";
+import { dirname as dirname13, join as join39 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -80920,10 +81083,10 @@ function hasNativeAnthropicMapping(config3) {
   ];
   return models.some((m) => m && parseModelSpec(m).provider === "native-anthropic");
 }
-function wantsAnthropicApiBilling(config3) {
+function wantsAnthropicApiBilling(config3, env = process.env) {
   if (config3.anthropicApiBilling)
     return true;
-  const raw2 = process.env[ENV.CLAUDISH_ANTHROPIC_API_BILLING];
+  const raw2 = env[ENV.CLAUDISH_ANTHROPIC_API_BILLING];
   if (raw2 !== undefined && raw2 !== "" && raw2 !== "0" && raw2.toLowerCase() !== "false")
     return true;
   try {
@@ -80932,12 +81095,32 @@ function wantsAnthropicApiBilling(config3) {
     return false;
   }
 }
+function shouldHideIncidentalAnthropicKey(config3, env = process.env) {
+  if (!hasNativeAnthropicMapping(config3))
+    return false;
+  if (!env.ANTHROPIC_API_KEY)
+    return false;
+  return !wantsAnthropicApiBilling(config3, env);
+}
+function hasResolvableAnthropicAuth(deps = {}) {
+  const env = deps.env ?? process.env;
+  const fileExists = deps.fileExists ?? existsSync30;
+  const keychainProbe = deps.keychainProbe ?? defaultKeychainAnthropicProbe;
+  if (env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN)
+    return true;
+  if (fileExists(join39(homedir34(), ".claude", ".credentials.json")))
+    return true;
+  return keychainProbe();
+}
+function shouldPreserveNativeAuth(config3) {
+  return hasNativeAnthropicMapping(config3) || classifierPassthroughEnabled(config3) && hasResolvableAnthropicAuth();
+}
 function isProxyAuthMode(config3) {
-  return !config3.monitor && !hasNativeAnthropicMapping(config3);
+  return !config3.monitor && !shouldPreserveNativeAuth(config3);
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join38(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join39(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
@@ -80958,9 +81141,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join38(homeDir, ".claudish");
+  const claudishDir = join39(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join38(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join39(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -81092,7 +81275,7 @@ process.stdin.on('end', () => {
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync18(dirname13(tokenFilePath), { recursive: true });
+    mkdirSync19(dirname13(tokenFilePath), { recursive: true });
     writeFileSync21(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
@@ -81124,7 +81307,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join38(dir, name);
+    const full = join39(dir, name);
     try {
       if (statSync5(full).mtimeMs >= cutoff)
         continue;
@@ -81153,9 +81336,9 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join38(homedir34(), ".claude", "settings.json"),
-    join38(cwd, ".claude", "settings.json"),
-    join38(cwd, ".claude", "settings.local.json")
+    join39(homedir34(), ".claude", "settings.json"),
+    join39(cwd, ".claude", "settings.json"),
+    join39(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
@@ -81196,13 +81379,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join38(homeDir, ".claudish");
+  const claudishDir = join39(homeDir, ".claudish");
   try {
-    mkdirSync18(claudishDir, { recursive: true });
+    mkdirSync19(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join38(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join38(claudishDir, `tokens-${port}.json`);
+  const tempPath = join39(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join39(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -81398,12 +81581,15 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
       env[ENV.ANTHROPIC_MODEL] = modelId;
       env[ENV.ANTHROPIC_SMALL_FAST_MODEL] = modelId;
     }
-    if (hasNativeAnthropicMapping(config3)) {
-      if (process.env.ANTHROPIC_API_KEY && !wantsAnthropicApiBilling(config3)) {
+    if (shouldPreserveNativeAuth(config3)) {
+      if (shouldHideIncidentalAnthropicKey(config3)) {
         delete env.ANTHROPIC_API_KEY;
         hidAnthropicApiKey = true;
       }
     } else {
+      if (classifierPassthroughEnabled(config3)) {
+        console.error("[claudish] classifier passthrough enabled but no Anthropic credentials detected \u2014 " + "classifier requests will fail to authenticate against api.anthropic.com. " + "Map a role to a native Claude model (e.g. --model-sonnet claude-sonnet-5) or set ANTHROPIC_API_KEY.");
+      }
       env.ANTHROPIC_API_KEY = "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx";
       env.ANTHROPIC_AUTH_TOKEN = "placeholder-token-not-used-proxy-handles-auth";
       const realWindow = await computeMainThreadContextWindow(config3);
@@ -81453,7 +81639,7 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
     const home = homedir34();
-    const localPath = isWindows2() ? join38(home, ".claude", "local", "claude.exe") : join38(home, ".claude", "local", "claude");
+    const localPath = isWindows2() ? join39(home, ".claude", "local", "claude.exe") : join39(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -81538,15 +81724,15 @@ async function findClaudeBinary() {
     }
   }
   const home = homedir34();
-  const localPath = isWindows3 ? join38(home, ".claude", "local", "claude.exe") : join38(home, ".claude", "local", "claude");
+  const localPath = isWindows3 ? join39(home, ".claude", "local", "claude.exe") : join39(home, ".claude", "local", "claude");
   if (existsSync30(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join38(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join38(home, ".npm-global", "claude.cmd"),
-      join38(home, "node_modules", ".bin", "claude.cmd")
+      join39(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join39(home, ".npm-global", "claude.cmd"),
+      join39(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
       if (existsSync30(path2)) {
@@ -81557,11 +81743,11 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join38(home, ".npm-global/bin/claude"),
-      join38(home, ".local/bin/claude"),
-      join38(home, "node_modules/.bin/claude"),
+      join39(home, ".npm-global/bin/claude"),
+      join39(home, ".local/bin/claude"),
+      join39(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join38(home, "../usr/bin/claude")
+      join39(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
       if (existsSync30(path2)) {
@@ -81601,7 +81787,21 @@ async function checkClaudeInstalled() {
   const binary = await findClaudeBinary();
   return binary !== null;
 }
-var restoreTerminal = null, STALE_TOKEN_FILE_MS, MAX_TOKEN_FILES_SCANNED = 4000, CLAUDE_CODE_DEFAULT_MAX_CONTEXT = 200000, USER_STATUS_LINE_TIMEOUT_SECONDS = 3, MIN_AUTO_COMPACT_WINDOW = 200000;
+var restoreTerminal = null, macosKeychainAnthropicResult, defaultKeychainAnthropicProbe = () => {
+  if (process.platform !== "darwin")
+    return false;
+  if (macosKeychainAnthropicResult !== undefined)
+    return macosKeychainAnthropicResult;
+  try {
+    const res = spawnSync5("security", ["find-generic-password", "-s", "Claude Code-credentials"], {
+      stdio: "ignore"
+    });
+    macosKeychainAnthropicResult = !res.error && res.status === 0;
+  } catch {
+    macosKeychainAnthropicResult = false;
+  }
+  return macosKeychainAnthropicResult;
+}, STALE_TOKEN_FILE_MS, MAX_TOKEN_FILES_SCANNED = 4000, CLAUDE_CODE_DEFAULT_MAX_CONTEXT = 200000, USER_STATUS_LINE_TIMEOUT_SECONDS = 3, MIN_AUTO_COMPACT_WINDOW = 200000;
 var init_claude_runner = __esm(() => {
   init_model_catalog();
   init_config2();
@@ -81623,18 +81823,18 @@ __export(exports_diag_output, {
   NullDiagOutput: () => NullDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync19, unlinkSync as unlinkSync11, writeFileSync as writeFileSync22 } from "fs";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync20, unlinkSync as unlinkSync11, writeFileSync as writeFileSync22 } from "fs";
 import { homedir as homedir35 } from "os";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 function getClaudishDir() {
-  const dir = join39(homedir35(), ".claudish");
+  const dir = join40(homedir35(), ".claudish");
   try {
-    mkdirSync19(dir, { recursive: true });
+    mkdirSync20(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join39(getClaudishDir(), `diag-${process.pid}.log`);
+  return join40(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -82232,7 +82432,7 @@ __export(exports_session_discovery, {
 import { execFile, execFileSync as execFileSync2 } from "child_process";
 import { closeSync as closeSync6, openSync as openSync6, readSync, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
 import { homedir as homedir36 } from "os";
-import { basename, join as join40 } from "path";
+import { basename, join as join41 } from "path";
 function slugForPath(absPath) {
   return absPath.replace(/[/.]/g, "-");
 }
@@ -82281,7 +82481,7 @@ function projectDirs() {
   }
 }
 function sessionsIn(dirName) {
-  const dir = join40(PROJECTS_DIR, dirName);
+  const dir = join41(PROJECTS_DIR, dirName);
   let names;
   try {
     names = readdirSync7(dir).filter((n) => n.endsWith(".jsonl"));
@@ -82290,7 +82490,7 @@ function sessionsIn(dirName) {
   }
   const rows = [];
   for (const n of names) {
-    const file2 = join40(dir, n);
+    const file2 = join41(dir, n);
     try {
       const st = statSync6(file2);
       if (st.size === 0)
@@ -82649,7 +82849,7 @@ function findLatestSessionId(cwd = process.cwd(), sinceMs = 0) {
 }
 var ENTRYPOINT_BYTES = 8192, PROJECTS_DIR, ACTIVE_WINDOW_MS = 120000, HEAD_BYTES, TAIL_BYTES, HARNESS_ENVELOPES, DEEP_TAIL_BYTES, RECENT_AI_TURNS = 5, RECENT_USER_TURNS = 1;
 var init_session_discovery = __esm(() => {
-  PROJECTS_DIR = join40(homedir36(), ".claude", "projects");
+  PROJECTS_DIR = join41(homedir36(), ".claude", "projects");
   HEAD_BYTES = 64 * 1024;
   TAIL_BYTES = 128 * 1024;
   HARNESS_ENVELOPES = [
@@ -84343,9 +84543,9 @@ __export(exports_session_stats, {
 });
 import { readFileSync as readFileSync31 } from "fs";
 import { homedir as homedir37 } from "os";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 function tokenFilePath(port) {
-  return process.env.CLAUDISH_TOKEN_FILE || join41(homedir37(), ".claudish", `tokens-${port}.json`);
+  return process.env.CLAUDISH_TOKEN_FILE || join42(homedir37(), ".claudish", `tokens-${port}.json`);
 }
 function readSessionStats(port, opts) {
   let raw2;
@@ -84691,7 +84891,7 @@ init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
 import { existsSync as existsSync31, readFileSync as readFileSync32 } from "fs";
-import { join as join42, resolve as resolve5 } from "path";
+import { join as join43, resolve as resolve5 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -84952,7 +85152,7 @@ async function runCli() {
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join42(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join43(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         const { setupSession: setupSession2, runModels: runModels2 } = await Promise.resolve().then(() => (init_team_orchestrator(), exports_team_orchestrator));
         setupSession2(sessionPath, cliConfig.team, prompt);
@@ -84962,7 +85162,7 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join42(sessionPath, `response-${anonId}.md`);
+          const responsePath = join43(sessionPath, `response-${anonId}.md`);
           try {
             const raw2 = readFileSync32(responsePath, "utf-8").trim();
             try {
@@ -85169,7 +85369,8 @@ Team Status`);
       isInteractive: cliConfig.interactive,
       advisorModels: cliConfig.advisorModels,
       advisorCollector: cliConfig.advisorCollector,
-      modelChain: cliConfig.monitor ? undefined : cliConfig.modelChain
+      modelChain: cliConfig.monitor ? undefined : cliConfig.modelChain,
+      classifier: resolveClassifierConfig(cliConfig, process.env)
     }));
     const diag = createDiagOutput2({
       interactive: cliConfig.interactive,

package/package.json

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