claudish 7.28.0 → 7.29.1

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.28.0";
+var VERSION = "7.29.1";
 
 // src/logger.ts
 var exports_logger = {};
@@ -37099,13 +37099,15 @@ var init_config = __esm(() => {
   SeveritySchema = exports_external.enum(["off", "warn", "fix"]);
   BehaviorConfigSchema = exports_external.object({
     preset: exports_external.string().optional(),
+    telemetry: exports_external.object({ enabled: exports_external.boolean().optional() }).optional(),
     rules: exports_external.record(exports_external.string(), SeveritySchema).optional(),
     hooks: exports_external.array(exports_external.string()).optional(),
     observer: exports_external.object({
       enabled: exports_external.boolean().optional(),
-      mode: exports_external.enum(["off", "suggest", "enforce"]).optional(),
+      mode: exports_external.enum(["off", "suggest"]).optional(),
       model: exports_external.string().optional(),
-      timeoutMs: exports_external.number().int().positive().optional()
+      timeoutMs: exports_external.number().int().positive().optional(),
+      watchTools: exports_external.array(exports_external.string()).optional()
     }).optional()
   });
 });
@@ -37172,17 +37174,274 @@ var init_harness = __esm(() => {
   PLAN_MODE_HINT = /plan file|create your plan at|Plan mode is active|Plan mode still active/i;
 });
 
+// src/behavior/journal.ts
+import { appendFile as appendFile2, mkdir, stat } from "fs/promises";
+import { homedir as homedir17 } from "os";
+import { dirname as dirname6, join as join17 } from "path";
+function classifyPath(observed, expected) {
+  if (!observed)
+    return "not_applicable";
+  if (!expected)
+    return "no_expectation";
+  if (observed === expected)
+    return "as_expected";
+  const dirOf = (p) => p.slice(0, Math.max(0, p.lastIndexOf("/")));
+  return dirOf(observed) === dirOf(expected) ? "same_dir_wrong_name" : "outside_expected_dir";
+}
+function journalPath() {
+  return join17(homedir17(), ".claudish", "behavior-journal.jsonl");
+}
+async function recordDecision(entry, path = journalPath()) {
+  try {
+    const size = await stat(path).then((s) => s.size, () => 0);
+    if (size > MAX_JOURNAL_BYTES) {
+      if (!capWarned) {
+        capWarned = true;
+        log(`[behavior:journal] ${path} exceeded ${Math.round(MAX_JOURNAL_BYTES / 1e6)}MB \u2014 ` + "no longer recording. Archive or delete it to resume.");
+      }
+      return;
+    }
+    if (size === 0)
+      await mkdir(dirname6(path), { recursive: true }).catch(() => {});
+    await appendFile2(path, `${JSON.stringify(entry)}
+`);
+  } catch (err) {
+    log(`[behavior:journal] could not record: ${err}`);
+  }
+}
+var MAX_JOURNAL_BYTES, capWarned = false;
+var init_journal = __esm(() => {
+  init_logger();
+  MAX_JOURNAL_BYTES = 32 * 1024 * 1024;
+});
+
+// src/behavior/observer/digest.ts
+var exports_digest = {};
+__export(exports_digest, {
+  buildDigest: () => buildDigest
+});
+function buildDigest(params) {
+  const digest = {
+    model: params.model,
+    toolNames: params.toolNames.slice(0, MAX_TOOL_NAMES),
+    harness: params.harness,
+    ruleVocabulary: params.ruleVocabulary
+  };
+  if (params.call) {
+    const paths = [];
+    for (const [key, value] of Object.entries(params.call.args)) {
+      if (PATH_KEYS.has(key) && typeof value === "string")
+        paths.push(value);
+    }
+    digest.proposedCall = {
+      name: params.call.name,
+      argKeys: Object.keys(params.call.args),
+      paths: paths.length > 0 ? paths : undefined
+    };
+  }
+  return digest;
+}
+var MAX_TOOL_NAMES = 40, PATH_KEYS;
+var init_digest = __esm(() => {
+  PATH_KEYS = new Set(["file_path", "path", "notebook_path", "filePath"]);
+});
+
+// src/providers/ollama-discovery.ts
+function ollamaBaseUrl() {
+  return process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+}
+async function fetchOllamaModels(options = {}) {
+  const { enrichCapabilities = true } = options;
+  const host = ollamaBaseUrl();
+  try {
+    const response = await fetch(`${host}/api/tags`, {
+      signal: AbortSignal.timeout(3000)
+    });
+    if (!response.ok)
+      return [];
+    const data = await response.json();
+    const models = data.models || [];
+    const enriched = await Promise.all(models.map(async (m) => {
+      let capabilities = [];
+      if (enrichCapabilities) {
+        try {
+          const showResponse = await fetch(`${host}/api/show`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: m.name }),
+            signal: AbortSignal.timeout(2000)
+          });
+          if (showResponse.ok) {
+            const showData = await showResponse.json();
+            capabilities = showData.capabilities || [];
+          }
+        } catch {}
+      }
+      const nameLower = String(m.name).toLowerCase();
+      const supportsTools = capabilities.includes("tools");
+      const isEmbeddingModel = capabilities.includes("embedding") || nameLower.includes("embed");
+      const sizeInfo = m.details?.parameter_size || "unknown size";
+      const toolsIndicator = supportsTools ? "\u2713 tools" : "\u2717 no tools";
+      return {
+        id: `ollama/${m.name}`,
+        name: m.name,
+        description: `Local Ollama model (${sizeInfo}, ${toolsIndicator})`,
+        provider: "ollama",
+        pricing: { prompt: "0", completion: "0" },
+        isLocal: true,
+        supportsTools,
+        isEmbeddingModel,
+        capabilities,
+        details: m.details,
+        size: m.size
+      };
+    }));
+    return enriched.filter((m) => !m.isEmbeddingModel);
+  } catch {
+    return [];
+  }
+}
+
+// src/behavior/observer/client.ts
+var exports_client = {};
+__export(exports_client, {
+  resetObserverModelCache: () => resetObserverModelCache,
+  observe: () => observe
+});
+function isGenuinelyLocal(model) {
+  if (/[-:]cloud$/i.test(model.name))
+    return false;
+  return (model.size ?? 0) >= MIN_LOCAL_MODEL_BYTES;
+}
+async function resolveObserverModel(config2) {
+  if (config2.observer?.model)
+    return config2.observer.model;
+  if (cachedModel !== undefined)
+    return cachedModel;
+  try {
+    const models = await fetchOllamaModels({ enrichCapabilities: false });
+    const usable = models.filter((m) => !m.isEmbeddingModel && isGenuinelyLocal(m));
+    if (usable.length === 0) {
+      log("[behavior:observer] No local Ollama models found \u2014 observer disabled for this run");
+      cachedModel = null;
+      return null;
+    }
+    usable.sort((a, b) => (a.size ?? Number.MAX_SAFE_INTEGER) - (b.size ?? Number.MAX_SAFE_INTEGER));
+    cachedModel = usable[0].name;
+    log(`[behavior:observer] Using discovered local model: ${cachedModel}`);
+    return cachedModel;
+  } catch (err) {
+    log(`[behavior:observer] Model discovery failed, observer disabled: ${err}`);
+    cachedModel = null;
+    return null;
+  }
+}
+function resetObserverModelCache() {
+  cachedModel = undefined;
+}
+async function observe(digest, config2) {
+  const mode = config2.observer?.mode ?? "suggest";
+  if (config2.observer?.enabled !== true || mode === "off")
+    return null;
+  const model = await resolveObserverModel(config2);
+  if (!model)
+    return null;
+  const timeoutMs = config2.observer?.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  try {
+    const response = await fetch(`${ollamaBaseUrl()}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      signal: AbortSignal.timeout(timeoutMs),
+      body: JSON.stringify({
+        model,
+        stream: false,
+        format: "json",
+        options: { temperature: 0 },
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: JSON.stringify(digest) }
+        ]
+      })
+    });
+    if (!response.ok) {
+      log(`[behavior:observer] HTTP ${response.status} \u2014 skipping`);
+      return null;
+    }
+    const body = await response.json();
+    const content = body?.message?.content;
+    if (typeof content !== "string")
+      return null;
+    const parsed = JSON.parse(content);
+    const ruleId = typeof parsed?.ruleId === "string" ? parsed.ruleId : null;
+    if (ruleId && !digest.ruleVocabulary.includes(ruleId)) {
+      log(`[behavior:observer] Discarding unknown ruleId "${ruleId}"`);
+      return null;
+    }
+    return {
+      ruleId,
+      confidence: typeof parsed?.confidence === "number" ? parsed.confidence : 0,
+      note: typeof parsed?.note === "string" ? parsed.note : undefined
+    };
+  } catch (err) {
+    log(`[behavior:observer] Skipped: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+}
+var DEFAULT_TIMEOUT_MS2 = 1500, SYSTEM_PROMPT = `You audit an AI coding agent for violations of Claude Code's conventions.
+You receive a JSON digest: the tools available, detected harness state, and the tool call the agent proposes.
+Decide whether the proposed call violates one of the rules listed in ruleVocabulary.
+
+Reply with ONLY a JSON object, no prose:
+{"ruleId": "<id from ruleVocabulary, or null>", "confidence": <0-1>, "note": "<short reason>"}
+
+Return ruleId null unless you are confident. A false positive is worse than a miss.`, MIN_LOCAL_MODEL_BYTES, cachedModel;
+var init_client = __esm(() => {
+  init_logger();
+  MIN_LOCAL_MODEL_BYTES = 50 * 1024 * 1024;
+});
+
+// src/behavior/observer/live-log.ts
+var exports_live_log = {};
+__export(exports_live_log, {
+  recordLiveDivergence: () => recordLiveDivergence
+});
+import { appendFile as appendFile3 } from "fs/promises";
+import { homedir as homedir18 } from "os";
+import { join as join18 } from "path";
+function defaultPath() {
+  return join18(homedir18(), ".claudish", "behavior-divergences.jsonl");
+}
+async function recordLiveDivergence(entry, path = defaultPath()) {
+  try {
+    await appendFile3(path, `${JSON.stringify(entry)}
+`);
+  } catch (err) {
+    log(`[behavior:observer] could not append divergence: ${err}`);
+  }
+}
+var init_live_log = __esm(() => {
+  init_logger();
+});
+
 // src/behavior/engine.ts
 class BehaviorSession {
   active;
   modelId;
   providerName;
+  config;
   facts = { planModeActive: false };
   bufferedTools = new Set;
-  constructor(active, modelId, providerName) {
+  constructor(active, modelId, providerName, config2 = {}) {
     this.active = active;
     this.modelId = modelId;
     this.providerName = providerName;
+    this.config = config2;
+  }
+  get observerOn() {
+    return this.config.observer?.enabled === true && (this.config.observer.mode ?? "suggest") !== "off";
+  }
+  observerWatchList() {
+    return this.config.observer?.watchTools ?? ["Write", "Edit", "NotebookEdit", "ExitPlanMode"];
   }
   armBuffering() {
     const armed = new Set;
@@ -37194,6 +37453,10 @@ class BehaviorSession {
       for (const t of rule.interceptsTools ?? [])
         armed.add(t);
     }
+    if (this.observerOn) {
+      for (const t of this.observerWatchList())
+        armed.add(t);
+    }
     this.bufferedTools = armed;
   }
   get harness() {
@@ -37275,13 +37538,80 @@ class BehaviorSession {
           log(`[behavior] ${rule.id} (warn-only, not applied): ${action.reason}`);
           continue;
         }
+        this.journal("tool_call", "repaired", {
+          ruleId: rule.id,
+          toolName,
+          argKeys: Object.keys(args),
+          observedPath: typeof args.file_path === "string" ? args.file_path : undefined,
+          expectedPath: this.facts.planFilePath,
+          note: action.reason
+        });
         args = action.args;
         changed = true;
         log(`[behavior] ${rule.id} repaired ${toolName}: ${action.reason}`);
       }
     }
+    if (!changed) {
+      this.journal("tool_call", "ignored", {
+        toolName,
+        argKeys: Object.keys(args),
+        observedPath: typeof args.file_path === "string" ? args.file_path : undefined,
+        expectedPath: this.facts.planFilePath
+      });
+    }
+    if (this.observerOn && !changed) {
+      this.consultObserver(toolName, args);
+    }
     return changed ? JSON.stringify(args) : null;
   }
+  journal(surface, decision, detail) {
+    recordDecision({
+      ts: new Date().toISOString(),
+      model: this.modelId,
+      provider: this.providerName,
+      surface,
+      decision,
+      ruleId: detail.ruleId,
+      toolName: detail.toolName,
+      argKeys: detail.argKeys,
+      pathRelation: classifyPath(detail.observedPath, detail.expectedPath),
+      local: {
+        observedPath: detail.observedPath,
+        expectedPath: detail.expectedPath,
+        note: detail.note
+      }
+    });
+  }
+  async consultObserver(toolName, args) {
+    try {
+      const { buildDigest: buildDigest2 } = await Promise.resolve().then(() => (init_digest(), exports_digest));
+      const { observe: observe2 } = await Promise.resolve().then(() => (init_client(), exports_client));
+      const { recordLiveDivergence: recordLiveDivergence2 } = await Promise.resolve().then(() => (init_live_log(), exports_live_log));
+      const digest = buildDigest2({
+        model: this.modelId,
+        toolNames: [...this.bufferedTools],
+        harness: this.facts,
+        ruleVocabulary: this.active.map((a) => a.rule.id),
+        call: { name: toolName, args }
+      });
+      const verdict = await observe2(digest, this.config);
+      if (!verdict?.ruleId)
+        return;
+      log(`[behavior:observer] flagged ${toolName} as ${verdict.ruleId} (confidence ${verdict.confidence})${verdict.note ? `: ${verdict.note}` : ""}`);
+      await recordLiveDivergence2({
+        source: "observer",
+        ts: new Date().toISOString(),
+        model: this.modelId,
+        toolName,
+        ruleId: verdict.ruleId,
+        confidence: verdict.confidence,
+        note: verdict.note,
+        paths: digest.proposedCall?.paths
+      });
+    } catch (err) {
+      log(`[behavior:observer] consult failed: ${err}`);
+    }
+  }
   applyAction(ruleId, severity, action, ctx) {
     if (action.type === "warn") {
       log(`[behavior] ${ruleId} (warn): ${action.message}`);
@@ -37359,13 +37689,14 @@ class BehaviorEngine {
     if (active.length > 0) {
       log(`[behavior] ${active.length} rule(s) active for ${params.modelId}: ` + active.map((a) => `${a.rule.id}=${a.severity}`).join(", "));
     }
-    return new BehaviorSession(active, params.modelId, params.providerName);
+    return new BehaviorSession(active, params.modelId, params.providerName, this.config);
   }
 }
 var init_engine = __esm(() => {
   init_logger();
   init_config();
   init_harness();
+  init_journal();
 });
 
 // src/behavior/rules/plan-mode.ts
@@ -37497,75 +37828,118 @@ var init_hooks = __esm(() => {
   init_logger();
 });
 
-// src/behavior/observer/digest.ts
-var PATH_KEYS;
-var init_digest = __esm(() => {
-  PATH_KEYS = new Set(["file_path", "path", "notebook_path", "filePath"]);
-});
-
-// src/providers/ollama-discovery.ts
-function ollamaBaseUrl() {
-  return process.env.OLLAMA_HOST || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+// src/behavior/observer/corpus.ts
+import { appendFileSync as appendFileSync3, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join19 } from "path";
+function directoryOf2(filePath) {
+  const slash = filePath.lastIndexOf("/");
+  return slash > 0 ? filePath.slice(0, slash) : undefined;
 }
-async function fetchOllamaModels(options = {}) {
-  const { enrichCapabilities = true } = options;
-  const host = ollamaBaseUrl();
+function writeTargetsOf(row) {
+  const content = row?.message?.content;
+  if (!Array.isArray(content))
+    return [];
+  const paths = [];
+  for (const block of content) {
+    if (block?.type !== "tool_use" || !WRITE_TOOLS2.has(block.name))
+      continue;
+    const p = block.input?.file_path;
+    if (typeof p === "string")
+      paths.push(p);
+  }
+  return paths;
+}
+function replayTranscript(file2) {
+  let text;
   try {
-    const response = await fetch(`${host}/api/tags`, {
-      signal: AbortSignal.timeout(3000)
-    });
-    if (!response.ok)
-      return [];
-    const data = await response.json();
-    const models = data.models || [];
-    const enriched = await Promise.all(models.map(async (m) => {
-      let capabilities = [];
-      if (enrichCapabilities) {
-        try {
-          const showResponse = await fetch(`${host}/api/show`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ name: m.name }),
-            signal: AbortSignal.timeout(2000)
-          });
-          if (showResponse.ok) {
-            const showData = await showResponse.json();
-            capabilities = showData.capabilities || [];
-          }
-        } catch {}
-      }
-      const nameLower = String(m.name).toLowerCase();
-      const supportsTools = capabilities.includes("tools");
-      const isEmbeddingModel = capabilities.includes("embedding") || nameLower.includes("embed");
-      const sizeInfo = m.details?.parameter_size || "unknown size";
-      const toolsIndicator = supportsTools ? "\u2713 tools" : "\u2717 no tools";
-      return {
-        id: `ollama/${m.name}`,
-        name: m.name,
-        description: `Local Ollama model (${sizeInfo}, ${toolsIndicator})`,
-        provider: "ollama",
-        pricing: { prompt: "0", completion: "0" },
-        isLocal: true,
-        supportsTools,
-        isEmbeddingModel,
-        capabilities,
-        details: m.details,
-        size: m.size
-      };
-    }));
-    return enriched.filter((m) => !m.isEmbeddingModel);
+    text = readFileSync12(file2, "utf8");
   } catch {
     return [];
   }
+  if (!text.includes("ExitPlanMode"))
+    return [];
+  const out = [];
+  const planWrites = [];
+  let lastModel;
+  for (const line of text.split(`
+`)) {
+    if (!line)
+      continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (row?.message?.role === "assistant" && typeof row?.message?.model === "string") {
+      lastModel = row.message.model;
+    }
+    planWrites.push(...writeTargetsOf(row));
+    const record4 = divergenceOf(row, file2, planWrites, lastModel);
+    if (record4)
+      out.push(record4);
+  }
+  return out;
 }
-
-// src/behavior/observer/client.ts
-var init_client = __esm(() => {
-  init_logger();
-});
-
-// src/behavior/observer/corpus.ts
-var WRITE_TOOLS2;
+function divergenceOf(row, file2, planWrites, lastModel) {
+  const result = row?.toolUseResult;
+  if (!result || typeof result !== "object")
+    return null;
+  if (!("plan" in result) || typeof result.filePath !== "string")
+    return null;
+  const assignedPath = result.filePath;
+  const planDir = directoryOf2(assignedPath);
+  const observedPaths = planDir ? [...new Set(planWrites.filter((p) => directoryOf2(p) === planDir && p !== assignedPath))] : [];
+  return {
+    transcript: file2,
+    timestamp: row?.timestamp,
+    model: row?.message?.model ?? lastModel,
+    ruleId: RULE_ID,
+    assignedPath,
+    observedPaths,
+    outcome: result.plan === null ? "degraded" : "ok"
+  };
+}
+function listTranscripts(root) {
+  const files = [];
+  let projects;
+  try {
+    projects = readdirSync2(root);
+  } catch {
+    return files;
+  }
+  for (const project of projects) {
+    const dir = join19(root, project);
+    try {
+      if (!statSync2(dir).isDirectory())
+        continue;
+      for (const f of readdirSync2(dir)) {
+        if (f.endsWith(".jsonl"))
+          files.push(join19(dir, f));
+      }
+    } catch {}
+  }
+  return files;
+}
+function buildCorpus(options = {}) {
+  const root = options.projectsRoot ?? join19(homedir19(), ".claude", "projects");
+  const files = listTranscripts(root);
+  const records = [];
+  for (const f of files)
+    records.push(...replayTranscript(f));
+  if (options.write && records.length > 0) {
+    const outputPath = options.outputPath ?? join19(homedir19(), ".claudish", "behavior-divergences.jsonl");
+    try {
+      appendFileSync3(outputPath, `${records.map((r) => JSON.stringify(r)).join(`
+`)}
+`);
+      return { scanned: files.length, records, outputPath };
+    } catch {}
+  }
+  return { scanned: files.length, records };
+}
+var RULE_ID = "plan-mode/plan-file-path", WRITE_TOOLS2;
 var init_corpus = __esm(() => {
   WRITE_TOOLS2 = new Set(["Write", "Edit", "NotebookEdit"]);
 });
@@ -37979,7 +38353,7 @@ var init_openai = __esm(() => {
 });
 
 // src/providers/catalog-query.ts
-import { statSync as statSync2 } from "fs";
+import { statSync as statSync3 } from "fs";
 function project(entry) {
   return {
     modelId: entry.modelId,
@@ -37992,7 +38366,7 @@ function project(entry) {
 function getCachedEntries() {
   let mtimeMs;
   try {
-    mtimeMs = statSync2(ALL_MODELS_CACHE_PATH).mtimeMs;
+    mtimeMs = statSync3(ALL_MODELS_CACHE_PATH).mtimeMs;
   } catch {
     return null;
   }
@@ -38168,13 +38542,13 @@ var init_vision_proxy = __esm(() => {
 import {
   existsSync as existsSync14,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   renameSync,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir17 } from "os";
-import { join as join17 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join20 } from "path";
 function ensureDir() {
   if (!existsSync14(CLAUDISH_DIR)) {
     mkdirSync9(CLAUDISH_DIR, { recursive: true });
@@ -38184,7 +38558,7 @@ function readFromDisk() {
   try {
     if (!existsSync14(BUFFER_FILE))
       return [];
-    const raw2 = readFileSync12(BUFFER_FILE, "utf-8");
+    const raw2 = readFileSync13(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw2);
     if (!Array.isArray(parsed.events))
       return [];
@@ -38209,7 +38583,7 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed };
-    const tmpFile = join17(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    const tmpFile = join20(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
     writeFileSync9(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync(tmpFile, BUFFER_FILE);
     memoryCache = trimmed;
@@ -38282,8 +38656,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, flushScheduled = false;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join17(homedir17(), ".claudish");
-  BUFFER_FILE = join17(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join20(homedir20(), ".claudish");
+  BUFFER_FILE = join20(CLAUDISH_DIR, "stats-buffer.json");
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
     try {
@@ -40564,8 +40938,8 @@ var init_openai_responses_sse = __esm(() => {
 
 // src/handlers/shared/token-tracker.ts
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir18 } from "os";
-import { dirname as dirname6, join as join18 } from "path";
+import { homedir as homedir21 } from "os";
+import { dirname as dirname7, join as join21 } from "path";
 
 class TokenTracker {
   port;
@@ -40709,8 +41083,8 @@ class TokenTracker {
         data.quota_remaining = this.quotaRemaining;
       }
       const override = process.env.CLAUDISH_TOKEN_FILE;
-      const outPath = override || join18(homedir18(), ".claudish", `tokens-${this.port}.json`);
-      mkdirSync10(dirname6(outPath), { recursive: true });
+      const outPath = override || join21(homedir21(), ".claudish", `tokens-${this.port}.json`);
+      mkdirSync10(dirname7(outPath), { recursive: true });
       writeFileSync10(outPath, JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
@@ -41556,7 +41930,7 @@ var init_fallback_handler = __esm(() => {
 });
 
 // src/handlers/native-handler-advisor.ts
-import { appendFileSync as appendFileSync3 } from "fs";
+import { appendFileSync as appendFileSync4 } from "fs";
 function loadAdvisorSwapConfig(cliModels, cliCollector) {
   return {
     enabled: process.env.CLAUDISH_SWAP_ADVISOR === "1" || (cliModels?.length ?? 0) > 0,
@@ -41611,7 +41985,7 @@ function logAdvisorEvent(cfg, event) {
   const line = `${JSON.stringify({ ts: new Date().toISOString(), ...event })}
 `;
   try {
-    appendFileSync3(cfg.logPath, line);
+    appendFileSync4(cfg.logPath, line);
   } catch {}
 }
 function recordAdvisorEventsFromChunk(cfg, chunkText) {
@@ -42659,38 +43033,32 @@ function extractModelIds(body) {
   }
   return [];
 }
+function orderByCost(models) {
+  const sized = models.filter((m) => typeof m.size === "number");
+  const unsized = models.filter((m) => typeof m.size !== "number");
+  const bySize = [...sized].sort((a, b) => (a.size ?? Number.POSITIVE_INFINITY) - (b.size ?? Number.POSITIVE_INFINITY)).map((m) => m.name);
+  return [...bySize, ...rankProbeCandidates(unsized.map((m) => m.name))];
+}
 async function discoverViaOllama(baseUrl, cacheKey) {
   const cached2 = cacheGet(cacheKey.key, cacheKey.exclude);
   if (cached2 !== undefined)
     return cached2;
-  let connectionError;
-  let loadedRaw = [];
-  try {
-    loadedRaw = await fetchOllamaModels2(`${baseUrl}/api/ps`);
-  } catch (e) {
-    connectionError = classifyFetchError(e, `${baseUrl}/api/ps`);
-  }
-  let allRaw = loadedRaw;
-  if (allRaw.length === 0) {
-    try {
-      allRaw = await fetchOllamaModels2(`${baseUrl}/api/tags`);
-    } catch (e) {
-      connectionError ??= classifyFetchError(e, `${baseUrl}/api/tags`);
-    }
-  }
-  const candidates = allRaw.filter((m) => isChatCapable(m.name));
-  if (candidates.length === 0) {
-    const reason = connectionError ?? (allRaw.length === 0 ? `no models on ${baseUrl} (pull one: ollama pull llama3.2)` : `only embedding/non-chat models on ${baseUrl}`);
+  const [psResult, tagsResult] = await Promise.allSettled([
+    fetchOllamaModels2(`${baseUrl}/api/ps`),
+    fetchOllamaModels2(`${baseUrl}/api/tags`)
+  ]);
+  const loadedRaw = psResult.status === "fulfilled" ? psResult.value : [];
+  const tagsRaw = tagsResult.status === "fulfilled" ? tagsResult.value : [];
+  const connectionError = psResult.status === "rejected" ? classifyFetchError(psResult.reason, `${baseUrl}/api/ps`) : tagsResult.status === "rejected" ? classifyFetchError(tagsResult.reason, `${baseUrl}/api/tags`) : undefined;
+  const loaded = loadedRaw.filter((m) => isChatCapable(m.name));
+  const loadedNames = new Set(loaded.map((m) => m.name));
+  const rest = tagsRaw.filter((m) => isChatCapable(m.name) && !loadedNames.has(m.name));
+  if (loaded.length === 0 && rest.length === 0) {
+    const reason = connectionError ?? (loadedRaw.length === 0 && tagsRaw.length === 0 ? `no models on ${baseUrl} (pull one: ollama pull llama3.2)` : `only embedding/non-chat models on ${baseUrl}`);
     cacheSetFailure(cacheKey.key, reason);
     return { model: null, reason };
   }
-  const sized = candidates.filter((m) => typeof m.size === "number");
-  let ranked;
-  if (sized.length > 0) {
-    ranked = [...sized].sort((a, b) => (a.size ?? Number.POSITIVE_INFINITY) - (b.size ?? Number.POSITIVE_INFINITY)).map((m) => m.name);
-  } else {
-    ranked = rankProbeCandidates(candidates.map((m) => m.name));
-  }
+  const ranked = [...orderByCost(loaded), ...orderByCost(rest)];
   if (ranked.length === 0) {
     const reason = "no chat-capable model on Ollama endpoint";
     cacheSetFailure(cacheKey.key, reason);
@@ -43214,11 +43582,11 @@ var init_ollama_api_format = __esm(() => {
 });
 
 // src/providers/api-key-provenance.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
-import { homedir as homedir19 } from "os";
-import { join as join19, resolve as resolve2 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
+import { homedir as homedir22 } from "os";
+import { join as join22, resolve as resolve2 } from "path";
 function activeConfigPath() {
-  return activeGlobalConfigFile(join19(homedir19(), ".claudish", "config.json"));
+  return activeGlobalConfigFile(join22(homedir22(), ".claudish", "config.json"));
 }
 function configLayerLabel() {
   return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
@@ -43297,7 +43665,7 @@ function readDotenvKey(envVars) {
     const dotenvPath = resolve2(".env");
     if (!existsSync15(dotenvPath))
       return null;
-    const parsed = import_dotenv.parse(readFileSync13(dotenvPath, "utf-8"));
+    const parsed = import_dotenv.parse(readFileSync14(dotenvPath, "utf-8"));
     for (const v of envVars) {
       if (parsed[v])
         return parsed[v];
@@ -43312,7 +43680,7 @@ function readConfigKey(envVar) {
     const configPath = activeConfigPath();
     if (!existsSync15(configPath))
       return null;
-    const cfg = JSON.parse(readFileSync13(configPath, "utf-8"));
+    const cfg = JSON.parse(readFileSync14(configPath, "utf-8"));
     return cfg.apiKeys?.[envVar] || null;
   } catch {
     return null;
@@ -44870,9 +45238,9 @@ var init_poe = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { existsSync as existsSync16, readFileSync as readFileSync14, statSync as statSync3 } from "fs";
-import { homedir as homedir20 } from "os";
-import { join as join20 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync15, statSync as statSync4 } from "fs";
+import { homedir as homedir23 } from "os";
+import { join as join23 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -44912,10 +45280,10 @@ function loadDiskCache() {
   try {
     if (!existsSync16(CACHE_FILE))
       return false;
-    const stat = statSync3(CACHE_FILE);
-    const age = Date.now() - stat.mtimeMs;
+    const stat2 = statSync4(CACHE_FILE);
+    const age = Date.now() - stat2.mtimeMs;
     const isFresh = age < CACHE_TTL_MS2;
-    const raw2 = readFileSync14(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync15(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -44931,8 +45299,8 @@ var init_pricing_cache = __esm(() => {
   init_logger();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join20(homedir20(), ".claudish");
-  CACHE_FILE = join20(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join23(homedir23(), ".claudish");
+  CACHE_FILE = join23(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS2 = 24 * 60 * 60 * 1000;
 });
 
@@ -45389,20 +45757,20 @@ var init_proxy_server = __esm(() => {
 });
 
 // src/team-stats.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "fs";
+import { join as join24 } from "path";
 function statsDir(sessionPath) {
-  return join21(sessionPath, "stats");
+  return join24(sessionPath, "stats");
 }
 function tokenFileFor(sessionPath, anonId) {
-  return join21(statsDir(sessionPath), `${anonId}.json`);
+  return join24(statsDir(sessionPath), `${anonId}.json`);
 }
 function readTokenStats(sessionPath, anonId) {
   const path = tokenFileFor(sessionPath, anonId);
   if (!existsSync17(path))
     return null;
   try {
-    return JSON.parse(readFileSync15(path, "utf-8"));
+    return JSON.parse(readFileSync16(path, "utf-8"));
   } catch {
     return null;
   }
@@ -45550,7 +45918,7 @@ ${segs.join(" \xB7 ")}`;
 }
 function writeStatusFile(sessionPath, manifest, status, opts) {
   try {
-    writeFileSync11(join21(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+    writeFileSync11(join24(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
 `, "utf-8");
   } catch {}
 }
@@ -45578,11 +45946,11 @@ import {
   createWriteStream as createWriteStream2,
   existsSync as existsSync18,
   mkdirSync as mkdirSync11,
-  readFileSync as readFileSync16,
-  readdirSync as readdirSync2,
+  readFileSync as readFileSync17,
+  readdirSync as readdirSync3,
   writeFileSync as writeFileSync12
 } from "fs";
-import { join as join22, resolve as resolve3 } from "path";
+import { join as join25, resolve as resolve3 } from "path";
 function classifyRunOutput(opts) {
   const { outputSize, stdoutTail, stderr, minOutputBytes } = opts;
   const apiError = API_ERROR_RE.exec(stdoutTail);
@@ -45643,18 +46011,18 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync18(join22(sessionPath, "manifest.json"))) {
+  if (existsSync18(join25(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.`);
   }
-  mkdirSync11(join22(sessionPath, "work"), { recursive: true });
-  mkdirSync11(join22(sessionPath, "errors"), { recursive: true });
+  mkdirSync11(join25(sessionPath, "work"), { recursive: true });
+  mkdirSync11(join25(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync12(join22(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync18(join22(sessionPath, "input.md"))) {
+    writeFileSync12(join25(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync18(join25(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"));
@@ -45671,9 +46039,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync11(join22(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync11(join25(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync12(join22(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync12(join25(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -45687,17 +46055,17 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync12(join22(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync12(join25(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(readFileSync16(join22(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join22(sessionPath, "status.json");
-  const inputPath = join22(sessionPath, "input.md");
-  const inputContent = readFileSync16(inputPath, "utf-8");
+  const manifest = JSON.parse(readFileSync17(join25(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join25(sessionPath, "status.json");
+  const inputPath = join25(sessionPath, "input.md");
+  const inputContent = readFileSync17(inputPath, "utf-8");
   await prehydrateCredentialsForSpawn(Object.values(manifest.models).map((m) => m.model));
-  const statusCache = JSON.parse(readFileSync16(statusPath, "utf-8"));
+  const statusCache = JSON.parse(readFileSync17(statusPath, "utf-8"));
   function updateModelStatus(id, update) {
     statusCache.models[id] = { ...statusCache.models[id], ...update };
     writeFileSync12(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
@@ -45716,8 +46084,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join22(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join22(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join25(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join25(sessionPath, "errors", `${anonId}.log`);
     const args = ["--model", entry.model, "-y", "--stdin", "--quiet", ...opts.claudeFlags ?? []];
     updateModelStatus(anonId, {
       state: "RUNNING",
@@ -45899,30 +46267,30 @@ async function runModels(sessionPath, opts = {}) {
   return statusCache;
 }
 async function judgeResponses(sessionPath, opts = {}) {
-  const responseFiles = readdirSync2(sessionPath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
+  const responseFiles = readdirSync3(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] = readFileSync16(join22(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync17(join25(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync16(join22(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync17(join25(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync12(join22(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync12(join25(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join22(sessionPath, "judging");
+  const judgePath = join25(sessionPath, "judging");
   mkdirSync11(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));
-  writeFileSync12(join22(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync12(join25(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync16(join22(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync17(join25(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -45932,7 +46300,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync16(join22(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync17(join25(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -45990,12 +46358,12 @@ function buildJudgePrompt(input, responses) {
 }
 function parseJudgeVotes(judgePath, responseIds) {
   const votes = [];
-  const responseFiles = readdirSync2(judgePath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
+  const responseFiles = readdirSync3(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 = readFileSync16(join22(judgePath, file2), "utf-8");
+      content = readFileSync17(join25(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -46047,7 +46415,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync16(join22(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync17(join25(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -46102,14 +46470,14 @@ __export(exports_mcp_server, {
   parseAnthropicSse: () => parseAnthropicSse,
   formatTeamResult: () => formatTeamResult
 });
-import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync17, readdirSync as readdirSync3, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir21 } from "os";
-import { dirname as dirname7, join as join23 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, readFileSync as readFileSync18, readdirSync as readdirSync4, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir24 } from "os";
+import { dirname as dirname8, join as join26 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
   if (!forceRefresh && existsSync19(ALL_MODELS_CACHE_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync17(ALL_MODELS_CACHE_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync18(ALL_MODELS_CACHE_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
       const ageInDays = (Date.now() - lastUpdated.getTime()) / (1000 * 60 * 60 * 24);
       if (ageInDays <= CACHE_MAX_AGE_DAYS) {
@@ -46128,7 +46496,7 @@ async function loadAllModels(forceRefresh = false) {
     return models;
   } catch {
     if (existsSync19(ALL_MODELS_CACHE_PATH2)) {
-      const cacheData = JSON.parse(readFileSync17(ALL_MODELS_CACHE_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync18(ALL_MODELS_CACHE_PATH2, "utf-8"));
       return cacheData.models || [];
     }
     return [];
@@ -46695,7 +47063,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       let stderrFull = stderr_snippet || "";
       if (error_log_path) {
         try {
-          stderrFull = readFileSync17(error_log_path, "utf-8");
+          stderrFull = readFileSync18(error_log_path, "utf-8");
         } catch {}
       }
       const sessionData = {};
@@ -46703,26 +47071,26 @@ 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] = readFileSync17(join23(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync18(join26(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join23(sp, "errors");
+          const errorDir = join26(sp, "errors");
           if (existsSync19(errorDir)) {
-            for (const f of readdirSync3(errorDir)) {
+            for (const f of readdirSync4(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync17(join23(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync18(join26(errorDir, f), "utf-8");
                 } catch {}
               }
             }
           }
         } catch {}
         try {
-          for (const f of readdirSync3(sp)) {
+          for (const f of readdirSync4(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync17(join23(sp, f), "utf-8");
+                const content = readFileSync18(join26(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -46731,9 +47099,9 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join23(__dirname2, "../package.json");
+        const pkgPath = join26(__dirname2, "../package.json");
         if (existsSync19(pkgPath)) {
-          version2 = JSON.parse(readFileSync17(pkgPath, "utf-8")).version;
+          version2 = JSON.parse(readFileSync18(pkgPath, "utf-8")).version;
         }
       } catch {}
       const report = {
@@ -47130,9 +47498,9 @@ var init_mcp_server = __esm(() => {
   import_dotenv2 = __toESM(require_main(), 1);
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
-  __dirname2 = dirname7(__filename2);
-  CLAUDISH_CACHE_DIR = join23(homedir21(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join23(CLAUDISH_CACHE_DIR, "all-models.json");
+  __dirname2 = dirname8(__filename2);
+  CLAUDISH_CACHE_DIR = join26(homedir24(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join26(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",
@@ -47157,7 +47525,7 @@ var exports_serve_command = {};
 __export(exports_serve_command, {
   serveCommand: () => serveCommand
 });
-import { existsSync as existsSync20, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync19 } from "fs";
 function parseServeArgs(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -47181,7 +47549,7 @@ function loadModelMap(path) {
   }
   let raw2;
   try {
-    raw2 = readFileSync18(path, "utf-8");
+    raw2 = readFileSync19(path, "utf-8");
   } catch (e) {
     throw new Error(`failed to read --models file ${path}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -47253,6 +47621,127 @@ var init_serve_command = __esm(() => {
   init_proxy_server();
 });
 
+// src/behavior-command.ts
+var exports_behavior_command = {};
+__export(exports_behavior_command, {
+  behaviorCommand: () => behaviorCommand
+});
+function severityColor(sev) {
+  if (sev === "fix")
+    return green(sev);
+  if (sev === "warn")
+    return yellow(sev);
+  return dim2(sev);
+}
+function showRules(json2) {
+  const config3 = parseBehaviorConfig(loadConfig().behavior);
+  const rows = BUILTIN_RULES.map((rule) => ({
+    id: rule.id,
+    severity: resolveSeverity(rule.id, rule.defaultSeverity, config3),
+    defaultSeverity: rule.defaultSeverity,
+    intercepts: rule.interceptsTools ?? [],
+    description: rule.description
+  }));
+  if (json2) {
+    console.log(JSON.stringify({ rules: rows, observer: config3.observer ?? null }, null, 2));
+    return;
+  }
+  console.log(bold2(`
+Behavior rules
+`));
+  for (const r of rows) {
+    const overridden = r.severity !== r.defaultSeverity ? dim2(` (default ${r.defaultSeverity})`) : "";
+    console.log(`  ${severityColor(r.severity).padEnd(18)} ${r.id}${overridden}`);
+    console.log(`  ${dim2(r.description)}`);
+    if (r.intercepts.length > 0) {
+      console.log(`  ${dim2(`repairs: ${r.intercepts.join(", ")}`)}`);
+    }
+    console.log();
+  }
+  console.log(dim2(`  Rules are inactive for native Claude models by design.
+`));
+  const obs = config3.observer;
+  const obsState = obs?.enabled ? obs.mode ?? "suggest" : "off";
+  console.log(`  observer: ${obsState === "off" ? dim2("off") : green(obsState)}`);
+  if (obs?.model)
+    console.log(`  ${dim2(`observer model: ${obs.model}`)}`);
+  console.log();
+}
+function showCorpus(write, json2) {
+  const result = buildCorpus({ write });
+  if (json2) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const degraded = result.records.filter((r) => r.outcome === "degraded");
+  const ok = result.records.filter((r) => r.outcome === "ok");
+  const catchable = degraded.filter((r) => r.observedPaths.length > 0);
+  console.log(bold2(`
+Behavior divergence corpus
+`));
+  console.log(`  transcripts scanned : ${result.scanned}`);
+  console.log(`  plan-exit records   : ${result.records.length}`);
+  console.log(`  ${green("plan found")}          : ${ok.length}`);
+  console.log(`  ${yellow("degraded (no plan)")}  : ${degraded.length}`);
+  console.log(`  of those, a rule would have fired on ${catchable.length}
+`);
+  const byModel = new Map;
+  for (const r of result.records) {
+    const m = r.model ?? "unknown";
+    const e = byModel.get(m) ?? { ok: 0, degraded: 0 };
+    if (r.outcome === "degraded")
+      e.degraded++;
+    else
+      e.ok++;
+    byModel.set(m, e);
+  }
+  if (byModel.size > 0) {
+    console.log(bold2(`  by model (degraded / ok)
+`));
+    for (const [model, v] of [...byModel.entries()].sort((a, b) => b[1].degraded - a[1].degraded || b[1].ok - a[1].ok)) {
+      const flag = v.degraded > 0 ? yellow(String(v.degraded)) : dim2("0");
+      console.log(`    ${model.padEnd(26)} ${flag} / ${v.ok}`);
+    }
+    console.log();
+  }
+  if (result.outputPath) {
+    console.log(dim2(`  appended to ${result.outputPath}
+`));
+  } else if (write) {
+    console.log(dim2(`  nothing to write (no records found)
+`));
+  } else {
+    console.log(dim2(`  pass --write to append these records to the divergence log
+`));
+  }
+}
+async function behaviorCommand(argv) {
+  const json2 = argv.includes("--json");
+  const write = argv.includes("--write");
+  const action = argv.find((a) => !a.startsWith("-")) ?? "rules";
+  switch (action) {
+    case "rules":
+      showRules(json2);
+      return;
+    case "corpus":
+      showCorpus(write, json2);
+      return;
+    default:
+      console.error(`Unknown action "${action}".
+
+` + `Usage:
+` + `  claudish behavior rules  [--json]
+` + `  claudish behavior corpus [--write] [--json]
+`);
+      process.exit(1);
+  }
+}
+var green = (s) => `\x1B[32m${s}\x1B[0m`, yellow = (s) => `\x1B[33m${s}\x1B[0m`, dim2 = (s) => `\x1B[2m${s}\x1B[0m`, bold2 = (s) => `\x1B[1m${s}\x1B[0m`;
+var init_behavior_command = __esm(() => {
+  init_behavior();
+  init_profile_config();
+});
+
 // src/auth/credentials/source.ts
 function describeSourceSync(p, config3) {
   if (p.isLocal)
@@ -48169,8 +48658,8 @@ function assembleStyles() {
   styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
   Object.defineProperties(styles, {
     rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
+      value(red, green2, blue) {
+        if (red === green2 && green2 === blue) {
           if (red < 8) {
             return 16;
           }
@@ -48179,7 +48668,7 @@ function assembleStyles() {
           }
           return Math.round((red - 8) / 247 * 24) + 232;
         }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green2 / 255 * 5) + Math.round(blue / 255 * 5);
       },
       enumerable: false
     },
@@ -48215,24 +48704,24 @@ function assembleStyles() {
           return 90 + (code - 8);
         }
         let red;
-        let green;
+        let green2;
         let blue;
         if (code >= 232) {
           red = ((code - 232) * 10 + 8) / 255;
-          green = red;
+          green2 = red;
           blue = red;
         } else {
           code -= 16;
           const remainder = code % 36;
           red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
+          green2 = Math.floor(remainder / 6) / 5;
           blue = remainder % 6 / 5;
         }
-        const value = Math.max(red, green, blue) * 2;
+        const value = Math.max(red, green2, blue) * 2;
         if (value === 0) {
           return 30;
         }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green2) << 1 | Math.round(red));
         if (value === 2) {
           result += 60;
         }
@@ -48241,7 +48730,7 @@ function assembleStyles() {
       enumerable: false
     },
     rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      value: (red, green2, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green2, blue)),
       enumerable: false
     },
     hexToAnsi: {
@@ -48251,7 +48740,7 @@ function assembleStyles() {
   });
   return styles;
 }
-var ANSI_BACKGROUND_OFFSET = 10, wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`, wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var ANSI_BACKGROUND_OFFSET = 10, wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`, wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, wrapAnsi16m = (offset = 0) => (red, green2, blue) => `\x1B[${38 + offset};2;${red};${green2};${blue}m`, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
 var init_ansi_styles = __esm(() => {
   styles = {
     modifier: {
@@ -58653,7 +59142,7 @@ var init_RemoveFileError = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+external-editor@2.0.1+04f2146be16c61ef/node_modules/@inquirer/external-editor/dist/index.js
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync19, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync20, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
 import path from "path";
 import os from "os";
 import { randomUUID as randomUUID4 } from "crypto";
@@ -58769,7 +59258,7 @@ class ExternalEditor {
   }
   readTemporaryFile() {
     try {
-      const tempFileBuffer = readFileSync19(this.tempFile);
+      const tempFileBuffer = readFileSync20(this.tempFile);
       if (tempFileBuffer.length === 0) {
         this.text = "";
       } else {
@@ -59964,15 +60453,15 @@ async function geminiQuotaHandler() {
   }
 }
 async function codexQuotaHandler() {
-  const { readFileSync: readFileSync20, existsSync: existsSync21 } = await import("fs");
-  const { join: join24 } = await import("path");
-  const { homedir: homedir22 } = await import("os");
-  const credPath = join24(homedir22(), ".claudish", "codex-oauth.json");
+  const { readFileSync: readFileSync21, existsSync: existsSync21 } = await import("fs");
+  const { join: join27 } = await import("path");
+  const { homedir: homedir25 } = await import("os");
+  const credPath = join27(homedir25(), ".claudish", "codex-oauth.json");
   if (!existsSync21(credPath)) {
     console.error(`${RED}No Codex credentials found.${R} Run: ${B}claudish login codex${R}`);
     process.exit(1);
   }
-  const creds = JSON.parse(readFileSync20(credPath, "utf-8"));
+  const creds = JSON.parse(readFileSync21(credPath, "utf-8"));
   let email3 = "";
   try {
     const parts = creds.access_token.split(".");
@@ -60024,9 +60513,9 @@ async function codexQuotaHandler() {
   }
   let modelSlugs = [];
   try {
-    const modelsPath = join24(homedir22(), ".codex", "models_cache.json");
+    const modelsPath = join27(homedir25(), ".codex", "models_cache.json");
     if (existsSync21(modelsPath)) {
-      const cache2 = JSON.parse(readFileSync20(modelsPath, "utf-8"));
+      const cache2 = JSON.parse(readFileSync21(modelsPath, "utf-8"));
       modelSlugs = (cache2.models || []).map((m) => m.slug || m.id).filter(Boolean);
     }
   } catch {}
@@ -61397,6 +61886,8 @@ function annotateOAuthHint(result, provider, isOAuth) {
   const loginCommand2 = provider === "gemini-codeassist" ? "claudish login gemini" : provider === "vertex" ? "gcloud auth application-default login" : undefined;
   if (!loginCommand2)
     return result;
+  if (result.httpStatus === 403)
+    return result;
   const looksLikeAuthFailure = result.state === "auth-failed" || /auth|token|login|credential|unauthor/i.test(result.errorMessage || "");
   if (!looksLikeAuthFailure)
     return result;
@@ -61679,29 +62170,34 @@ function isContentEvent(parsed, eventType) {
     return true;
   return false;
 }
+function withDetail(base, message) {
+  return message ? `${base} \u2014 ${message}` : base;
+}
 function describeProbeState(result) {
+  const status = result.httpStatus ?? "";
+  const latency = result.latencyMs ? ` \xB7 ${result.latencyMs}ms` : "";
   switch (result.state) {
     case "live":
       return `live \xB7 ${result.latencyMs}ms`;
     case "key-missing":
       return result.errorMessage ? `missing (${result.errorMessage})` : "missing";
     case "auth-failed":
-      return `auth failed \xB7 ${result.httpStatus ?? ""}${result.latencyMs ? ` \xB7 ${result.latencyMs}ms` : ""}`.trim();
+      return withDetail(`auth failed \xB7 ${status}${latency}`.trim(), result.errorMessage);
     case "model-not-found":
-      return `model not found \xB7 ${result.httpStatus ?? ""}${result.latencyMs ? ` \xB7 ${result.latencyMs}ms` : ""}`.trim();
+      return withDetail(`model not found \xB7 ${status}${latency}`.trim(), result.errorMessage);
     case "rate-limited":
-      return `rate limited \xB7 ${result.latencyMs}ms`;
+      return withDetail(`rate limited \xB7 ${result.latencyMs}ms`, result.errorMessage);
     case "out-of-credit":
-      return `out of credit \xB7 ${result.httpStatus ?? ""}${result.latencyMs ? ` \xB7 ${result.latencyMs}ms` : ""}`.trim();
+      return withDetail(`out of credit \xB7 ${status}${latency}`.trim(), result.errorMessage);
     case "server-error":
-      return `server error \xB7 ${result.httpStatus ?? ""} \xB7 ${result.latencyMs}ms`;
+      return withDetail(`server error \xB7 ${status} \xB7 ${result.latencyMs}ms`, result.errorMessage);
     case "timeout":
-      return `timeout \xB7 ${result.latencyMs}ms`;
+      return withDetail(`timeout \xB7 ${result.latencyMs}ms`, result.errorMessage);
     case "network-error":
-      return `network error \xB7 ${result.latencyMs}ms`;
+      return withDetail(`network error \xB7 ${result.latencyMs}ms`, result.errorMessage);
     case "error": {
-      const base = `error${result.httpStatus ? ` \xB7 ${result.httpStatus}` : ""}${result.latencyMs ? ` \xB7 ${result.latencyMs}ms` : ""}`;
-      return result.errorMessage ? `${base} \u2014 ${result.errorMessage}` : base;
+      const base = `error${result.httpStatus ? ` \xB7 ${result.httpStatus}` : ""}${latency}`;
+      return withDetail(base, result.errorMessage);
     }
   }
 }
@@ -61819,7 +62315,7 @@ function tokBarCells(tokensPerSec, maxTokPerSec, tokWidth) {
   const raw2 = Math.round(tokWidth * Math.max(0, tokensPerSec) / denom);
   return Math.min(tokWidth, Math.max(0, raw2));
 }
-var C, bold2, A, LATENCY_BUCKETS, latencyFg = "#ffffff", LATENCY_FG_ANSI = "\x1B[38;2;255;255;255m", ANSI_RESET = "\x1B[0m", STAGE_BG, STAGE_FG, STAGE_BG_ANSI;
+var C, bold3, A, LATENCY_BUCKETS, latencyFg = "#ffffff", LATENCY_FG_ANSI = "\x1B[38;2;255;255;255m", ANSI_RESET = "\x1B[0m", STAGE_BG, STAGE_FG, STAGE_BG_ANSI;
 var init_theme2 = __esm(() => {
   C = {
     bg: "#000000",
@@ -61850,10 +62346,10 @@ var init_theme2 = __esm(() => {
     chipKeyBg: "#3a3a3a",
     chipLabelBg: "#222222"
   };
-  bold2 = createTextAttributes({ bold: true });
+  bold3 = createTextAttributes({ bold: true });
   A = {
-    bold: bold2,
-    boldIf: (enabled) => enabled ? bold2 : undefined
+    bold: bold3,
+    boldIf: (enabled) => enabled ? bold3 : undefined
   };
   LATENCY_BUCKETS = [
     { maxMs: 500, hex: "#1f8f3b" },
@@ -63991,28 +64487,28 @@ import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync21,
   mkdirSync as mkdirSync13,
-  readFileSync as readFileSync20,
-  readdirSync as readdirSync4,
+  readFileSync as readFileSync21,
+  readdirSync as readdirSync5,
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync15
 } from "fs";
-import { homedir as homedir22 } from "os";
-import { dirname as dirname8, join as join24 } from "path";
+import { homedir as homedir25 } from "os";
+import { dirname as dirname9, join as join27 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join24(homedir22(), ".claudish");
+  const cacheDir = join27(homedir25(), ".claudish");
   if (!existsSync21(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
   try {
-    const files = readdirSync4(cacheDir);
+    const files = readdirSync5(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync7(join24(cacheDir, file2));
+        unlinkSync7(join27(cacheDir, file2));
         cleared++;
       }
     }
@@ -64422,14 +64918,14 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join24(homedir22(), ".claudish", ".legacy-litellm-hint-shown");
+      const markerFile = join27(homedir25(), ".claudish", ".legacy-litellm-hint-shown");
       if (!existsSync21(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
         }
         try {
-          mkdirSync13(dirname8(markerFile), { recursive: true });
+          mkdirSync13(dirname9(markerFile), { recursive: true });
           writeFileSync15(markerFile, new Date().toISOString(), "utf-8");
         } catch {}
       }
@@ -65189,261 +65685,261 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
 function printHelp() {
   const useColor = !!process.stdout.isTTY && !process.env.NO_COLOR;
   const c = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
-  const bold3 = c("1");
-  const dim2 = c("2");
+  const bold4 = c("1");
+  const dim3 = c("2");
   const cyan = c("36");
-  const green = c("32");
-  const yellow = c("33");
+  const green2 = c("32");
+  const yellow2 = c("33");
   const magenta = c("35");
   const blue = c("34");
-  const h = (title) => bold3(cyan(`\u258C ${title}`));
+  const h = (title) => bold4(cyan(`\u258C ${title}`));
   console.log(`
-${bold3("claudish")} ${dim2("\xB7")} Run Claude Code with any AI model
-${dim2("OpenRouter \xB7 Gemini \xB7 OpenAI \xB7 xAI \xB7 MiniMax \xB7 Kimi \xB7 GLM \xB7 Z.AI \xB7 Sakana \xB7 Poe \xB7 LiteLLM \xB7 Local")}
+${bold4("claudish")} ${dim3("\xB7")} Run Claude Code with any AI model
+${dim3("OpenRouter \xB7 Gemini \xB7 OpenAI \xB7 xAI \xB7 MiniMax \xB7 Kimi \xB7 GLM \xB7 Z.AI \xB7 Sakana \xB7 Poe \xB7 LiteLLM \xB7 Local")}
 
 ${h("USAGE")}
-  ${green("claudish")}                                ${dim2("# Interactive mode (default, model selector)")}
-  ${green("claudish")} ${yellow("[OPTIONS] <claude-args...>")}     ${dim2("# Single-shot mode (requires --model)")}
-  ${green("claudish")} ${green("--team")} ${yellow("a,b,c")} ${yellow('"prompt"')}          ${dim2("# Run models in parallel (magmux grid)")}
-  ${green("claudish")} ${green("--team")} ${yellow("a,b,c")} ${green("-f")} ${yellow("input.md")}       ${dim2("# Team mode with file input")}
+  ${green2("claudish")}                                ${dim3("# Interactive mode (default, model selector)")}
+  ${green2("claudish")} ${yellow2("[OPTIONS] <claude-args...>")}     ${dim3("# Single-shot mode (requires --model)")}
+  ${green2("claudish")} ${green2("--team")} ${yellow2("a,b,c")} ${yellow2('"prompt"')}          ${dim3("# Run models in parallel (magmux grid)")}
+  ${green2("claudish")} ${green2("--team")} ${yellow2("a,b,c")} ${green2("-f")} ${yellow2("input.md")}       ${dim3("# Team mode with file input")}
 
 ${h("MODEL ROUTING")}
-  ${bold3("New syntax:")} ${yellow("provider@model[:concurrency]")}
-    ${magenta("google@gemini-3-pro")}              ${dim2("Direct Google API (explicit)")}
-    ${magenta("openrouter@google/gemini-3-pro")}   ${dim2("OpenRouter (explicit)")}
-    ${magenta("oai@gpt-5.3")}                      ${dim2("Direct OpenAI API (shortcut)")}
-    ${magenta("ollama@llama3.2:3")}                ${dim2("Local Ollama, 3 concurrent requests")}
-    ${magenta("ollama@llama3.2:0")}                ${dim2("Local Ollama, no limits")}
-
-  ${bold3("Provider shortcuts:")}
-    ${magenta("g, gemini")}      ${dim2("->")} Google Gemini       ${dim2("google@gemini-3-pro")}
-    ${magenta("oai")}            ${dim2("->")} OpenAI Direct       ${dim2("oai@gpt-5.3")}
-    ${magenta("cx, codex")}      ${dim2("->")} OpenAI Codex        ${dim2("cx@gpt-5.3 (Responses API)")}
-    ${magenta("or")}             ${dim2("->")} OpenRouter          ${dim2("or@openai/gpt-5.3")}
-    ${magenta("x-ai, xai, grok")} ${dim2("->")} xAI / Grok         ${dim2("x-ai@grok-3")}
-    ${magenta("mm, mmax")}       ${dim2("->")} MiniMax Direct      ${dim2("mm@MiniMax-M2.1")}
-    ${magenta("mmc")}            ${dim2("->")} MiniMax Coding      ${dim2("mmc@MiniMax-M2.1")}
-    ${magenta("kimi, moon")}     ${dim2("->")} Kimi Direct         ${dim2("kimi@kimi-k2-thinking-turbo")}
-    ${magenta("kc")}             ${dim2("->")} Kimi Coding         ${dim2("kc@kimi-k2-thinking-turbo")}
-    ${magenta("glm, zhipu")}     ${dim2("->")} GLM Direct          ${dim2("glm@glm-4.7")}
-    ${magenta("gc")}             ${dim2("->")} GLM Coding          ${dim2("gc@glm-4.7")}
-    ${magenta("z-ai, zai")}      ${dim2("->")} Z.AI Direct         ${dim2("z-ai@glm-4.7")}
-    ${magenta("oc, llama, lc, meta")} ${dim2("->")} OllamaCloud    ${dim2("oc@llama-3.1")}
-    ${magenta("zen")}            ${dim2("->")} OpenCode Zen        ${dim2("zen@grok-code")}
-    ${magenta("zengo, zgo")}     ${dim2("->")} OpenCode Zen Go     ${dim2("zengo@grok-code")}
-    ${magenta("v, vertex")}      ${dim2("->")} Vertex AI           ${dim2("v@gemini-2.5-flash")}
-    ${magenta("go")}             ${dim2("->")} Gemini Code Assist  ${dim2("go@gemini-2.5-flash")}
-    ${magenta("poe")}            ${dim2("->")} Poe                 ${dim2("poe@GPT-4o")}
-    ${magenta("litellm, ll")}    ${dim2("->")} LiteLLM             ${dim2("ll@gpt-4o (needs LITELLM_BASE_URL)")}
-    ${magenta("ds")}             ${dim2("->")} DeepSeek            ${dim2("ds@deepseek-chat")}
-    ${magenta("sakana, fugu")}   ${dim2("->")} Sakana Fugu         ${dim2("fugu@fugu-ultra")}
-    ${magenta("sc")}             ${dim2("->")} Sakana Subscription ${dim2("sc@fugu-ultra")}
-    ${magenta("ollama")}         ${dim2("->")} Ollama (local)      ${dim2("ollama@llama3.2")}
-    ${magenta("lms, lmstudio")}  ${dim2("->")} LM Studio (local)   ${dim2("lms@qwen")}
-    ${magenta("vllm")}           ${dim2("->")} vLLM (local)        ${dim2("vllm@model")}
-    ${magenta("mlx")}            ${dim2("->")} MLX (local)         ${dim2("mlx@model")}
-
-  ${bold3("Native auto-detection")} ${dim2("(when no provider specified):")}
-    ${yellow("google/*, gemini-*")}      ${dim2("->")} Google API
-    ${yellow("openai/*, gpt-*, o1-*")}   ${dim2("->")} OpenAI API
-    ${yellow("x-ai/*, grok-*")}          ${dim2("->")} xAI
-    ${yellow("meta-llama/*, llama-*")}   ${dim2("->")} OllamaCloud
-    ${yellow("minimax/*, abab-*")}       ${dim2("->")} MiniMax API
-    ${yellow("moonshot/*, kimi-*")}      ${dim2("->")} Kimi API
-    ${yellow("zhipu/*, glm-*")}          ${dim2("->")} GLM API
-    ${yellow("sakana/*, fugu-*")}        ${dim2("->")} Sakana Fugu
-    ${yellow("poe:*")}                   ${dim2("->")} Poe
-    ${yellow("anthropic/*, claude-*")}   ${dim2("->")} Native Anthropic
-    ${yellow("(unknown vendor/)")}       ${dim2("->")} Error (use openrouter@vendor/model)
-
-  ${dim2("A defaultProvider (config / --default-provider) catches bare names that match no rule.")}
+  ${bold4("New syntax:")} ${yellow2("provider@model[:concurrency]")}
+    ${magenta("google@gemini-3-pro")}              ${dim3("Direct Google API (explicit)")}
+    ${magenta("openrouter@google/gemini-3-pro")}   ${dim3("OpenRouter (explicit)")}
+    ${magenta("oai@gpt-5.3")}                      ${dim3("Direct OpenAI API (shortcut)")}
+    ${magenta("ollama@llama3.2:3")}                ${dim3("Local Ollama, 3 concurrent requests")}
+    ${magenta("ollama@llama3.2:0")}                ${dim3("Local Ollama, no limits")}
+
+  ${bold4("Provider shortcuts:")}
+    ${magenta("g, gemini")}      ${dim3("->")} Google Gemini       ${dim3("google@gemini-3-pro")}
+    ${magenta("oai")}            ${dim3("->")} OpenAI Direct       ${dim3("oai@gpt-5.3")}
+    ${magenta("cx, codex")}      ${dim3("->")} OpenAI Codex        ${dim3("cx@gpt-5.3 (Responses API)")}
+    ${magenta("or")}             ${dim3("->")} OpenRouter          ${dim3("or@openai/gpt-5.3")}
+    ${magenta("x-ai, xai, grok")} ${dim3("->")} xAI / Grok         ${dim3("x-ai@grok-3")}
+    ${magenta("mm, mmax")}       ${dim3("->")} MiniMax Direct      ${dim3("mm@MiniMax-M2.1")}
+    ${magenta("mmc")}            ${dim3("->")} MiniMax Coding      ${dim3("mmc@MiniMax-M2.1")}
+    ${magenta("kimi, moon")}     ${dim3("->")} Kimi Direct         ${dim3("kimi@kimi-k2-thinking-turbo")}
+    ${magenta("kc")}             ${dim3("->")} Kimi Coding         ${dim3("kc@kimi-k2-thinking-turbo")}
+    ${magenta("glm, zhipu")}     ${dim3("->")} GLM Direct          ${dim3("glm@glm-4.7")}
+    ${magenta("gc")}             ${dim3("->")} GLM Coding          ${dim3("gc@glm-4.7")}
+    ${magenta("z-ai, zai")}      ${dim3("->")} Z.AI Direct         ${dim3("z-ai@glm-4.7")}
+    ${magenta("oc, llama, lc, meta")} ${dim3("->")} OllamaCloud    ${dim3("oc@llama-3.1")}
+    ${magenta("zen")}            ${dim3("->")} OpenCode Zen        ${dim3("zen@grok-code")}
+    ${magenta("zengo, zgo")}     ${dim3("->")} OpenCode Zen Go     ${dim3("zengo@grok-code")}
+    ${magenta("v, vertex")}      ${dim3("->")} Vertex AI           ${dim3("v@gemini-2.5-flash")}
+    ${magenta("go")}             ${dim3("->")} Gemini Code Assist  ${dim3("go@gemini-2.5-flash")}
+    ${magenta("poe")}            ${dim3("->")} Poe                 ${dim3("poe@GPT-4o")}
+    ${magenta("litellm, ll")}    ${dim3("->")} LiteLLM             ${dim3("ll@gpt-4o (needs LITELLM_BASE_URL)")}
+    ${magenta("ds")}             ${dim3("->")} DeepSeek            ${dim3("ds@deepseek-chat")}
+    ${magenta("sakana, fugu")}   ${dim3("->")} Sakana Fugu         ${dim3("fugu@fugu-ultra")}
+    ${magenta("sc")}             ${dim3("->")} Sakana Subscription ${dim3("sc@fugu-ultra")}
+    ${magenta("ollama")}         ${dim3("->")} Ollama (local)      ${dim3("ollama@llama3.2")}
+    ${magenta("lms, lmstudio")}  ${dim3("->")} LM Studio (local)   ${dim3("lms@qwen")}
+    ${magenta("vllm")}           ${dim3("->")} vLLM (local)        ${dim3("vllm@model")}
+    ${magenta("mlx")}            ${dim3("->")} MLX (local)         ${dim3("mlx@model")}
+
+  ${bold4("Native auto-detection")} ${dim3("(when no provider specified):")}
+    ${yellow2("google/*, gemini-*")}      ${dim3("->")} Google API
+    ${yellow2("openai/*, gpt-*, o1-*")}   ${dim3("->")} OpenAI API
+    ${yellow2("x-ai/*, grok-*")}          ${dim3("->")} xAI
+    ${yellow2("meta-llama/*, llama-*")}   ${dim3("->")} OllamaCloud
+    ${yellow2("minimax/*, abab-*")}       ${dim3("->")} MiniMax API
+    ${yellow2("moonshot/*, kimi-*")}      ${dim3("->")} Kimi API
+    ${yellow2("zhipu/*, glm-*")}          ${dim3("->")} GLM API
+    ${yellow2("sakana/*, fugu-*")}        ${dim3("->")} Sakana Fugu
+    ${yellow2("poe:*")}                   ${dim3("->")} Poe
+    ${yellow2("anthropic/*, claude-*")}   ${dim3("->")} Native Anthropic
+    ${yellow2("(unknown vendor/)")}       ${dim3("->")} Error (use openrouter@vendor/model)
+
+  ${dim3("A defaultProvider (config / --default-provider) catches bare names that match no rule.")}
 
 ${h("OPTIONS")}
-  ${green("-i, --interactive")}        Run in interactive mode (default when no prompt given)
-  ${green("-m, --model")} ${yellow("<model>")}      Model to use (required for single-shot mode)
-  ${green("--profile")} ${yellow("<name>")}         Use named profile for model mapping (default profile if omitted)
-  ${green("--default-provider")} ${yellow("<name>")} Fallback provider for bare model names (builtin or customEndpoints key)
-                           ${dim2("Precedence: this flag > CLAUDISH_DEFAULT_PROVIDER env > config.json")}
-  ${green("--anthropic-api-billing")}  Use your real ANTHROPIC_API_KEY for native Claude models
-                           ${dim2("(metered API billing). Default: the key is hidden so Claude Code")}
-                           ${dim2("uses your claude.ai subscription. Env: CLAUDISH_ANTHROPIC_API_BILLING")}
-                           ${dim2("Config: anthropicApiBilling: true")}
-  ${green("--config")} ${yellow("<file>")}          Use THIS config file for the run, fully replacing the machine
-                           ${dim2("global (~/.claudish/config.json) AND project (.claudish.json).")}
-                           ${dim2("A file naming no op:// source never touches 1Password (no prompt).")}
-                           ${dim2("Env vars still resolve first. Env: CLAUDISH_CONFIG")}
-  ${green("--op")} ${yellow("<op://glob>")}         Load API keys from a 1Password item glob (SDK-based, no op CLI)
-  ${green("--op")} ${yellow("<glob>")} ${green("--list")}      Preview which fields the glob would import (names only, no values)
-  ${green("--op-env")} ${yellow("<id>")}            Load env vars from a 1Password Environment (highest priority)
-  ${green("--port")} ${yellow("<port>")}            Proxy server port (default: random)
-  ${green("-d, --debug-claudish")}     Enable claudish debug logging to file (logs/claudish_*.log)
-                           ${dim2('Always-on: CLAUDISH_DEBUG=1 env var or "debug": true in config.json')}
-  ${green("--no-debug-claudish")}      Force debug logging off for this run (when globally enabled)
-  ${green("--log-off")}                Disable always-on structural logging (~/.claudish/logs/)
-  ${green("--log-diag")} ${yellow("<mode>")}        Diagnostic output: auto (default), logfile, off
-                           ${dim2('Also: CLAUDISH_DIAG_MODE env var or "diagMode" in config.json')}
-  ${green("--log-level")} ${yellow("<level>")}      Log verbosity: debug (full), info (truncated), minimal (labels)
-  ${green("-q, --quiet")}              Suppress [claudish] log messages (default in single-shot mode)
-  ${green("-v, --verbose")}            Show [claudish] log messages (default in interactive mode)
-  ${green("--json")}                   Output JSON for tool integration (implies --quiet)
-  ${green("--stdin")}                  Read prompt from stdin (large prompts / piping)
-  ${green("--free")}                   Show only FREE models in the interactive selector
-  ${green("--monitor")}                Monitor mode - proxy to REAL Anthropic API and log traffic
-  ${green("--advisor")} ${yellow('"m1,m2[:collector]"')}  Multi-model advisor replacement (implies --monitor)
-  ${green("-y, --auto-approve")}       Skip permission prompts (--dangerously-skip-permissions)
-  ${green("--no-auto-approve")}        Explicitly enable permission prompts (default)
-  ${green("--dangerous")}              Pass --dangerouslyDisableSandbox to Claude Code
-  ${green("--cost-track")}             Enable cost tracking for API usage
-  ${green("--cost-audit")}             Show cost analysis report
-  ${green("--cost-reset")}             Reset accumulated cost statistics
-  ${green("--version")}                Show version information
-  ${green("-h, --help")}               Show this help message
-  ${green("--help-ai")}                Show AI agent usage guide (file-based patterns, sub-agents)
-  ${green("--init")}                   Install Claudish skill in current project (.claude/skills/)
-  ${green("--")}                       Separator: everything after passes directly to Claude Code
+  ${green2("-i, --interactive")}        Run in interactive mode (default when no prompt given)
+  ${green2("-m, --model")} ${yellow2("<model>")}      Model to use (required for single-shot mode)
+  ${green2("--profile")} ${yellow2("<name>")}         Use named profile for model mapping (default profile if omitted)
+  ${green2("--default-provider")} ${yellow2("<name>")} Fallback provider for bare model names (builtin or customEndpoints key)
+                           ${dim3("Precedence: this flag > CLAUDISH_DEFAULT_PROVIDER env > config.json")}
+  ${green2("--anthropic-api-billing")}  Use your real ANTHROPIC_API_KEY for native Claude models
+                           ${dim3("(metered API billing). Default: the key is hidden so Claude Code")}
+                           ${dim3("uses your claude.ai subscription. Env: CLAUDISH_ANTHROPIC_API_BILLING")}
+                           ${dim3("Config: anthropicApiBilling: true")}
+  ${green2("--config")} ${yellow2("<file>")}          Use THIS config file for the run, fully replacing the machine
+                           ${dim3("global (~/.claudish/config.json) AND project (.claudish.json).")}
+                           ${dim3("A file naming no op:// source never touches 1Password (no prompt).")}
+                           ${dim3("Env vars still resolve first. Env: CLAUDISH_CONFIG")}
+  ${green2("--op")} ${yellow2("<op://glob>")}         Load API keys from a 1Password item glob (SDK-based, no op CLI)
+  ${green2("--op")} ${yellow2("<glob>")} ${green2("--list")}      Preview which fields the glob would import (names only, no values)
+  ${green2("--op-env")} ${yellow2("<id>")}            Load env vars from a 1Password Environment (highest priority)
+  ${green2("--port")} ${yellow2("<port>")}            Proxy server port (default: random)
+  ${green2("-d, --debug-claudish")}     Enable claudish debug logging to file (logs/claudish_*.log)
+                           ${dim3('Always-on: CLAUDISH_DEBUG=1 env var or "debug": true in config.json')}
+  ${green2("--no-debug-claudish")}      Force debug logging off for this run (when globally enabled)
+  ${green2("--log-off")}                Disable always-on structural logging (~/.claudish/logs/)
+  ${green2("--log-diag")} ${yellow2("<mode>")}        Diagnostic output: auto (default), logfile, off
+                           ${dim3('Also: CLAUDISH_DIAG_MODE env var or "diagMode" in config.json')}
+  ${green2("--log-level")} ${yellow2("<level>")}      Log verbosity: debug (full), info (truncated), minimal (labels)
+  ${green2("-q, --quiet")}              Suppress [claudish] log messages (default in single-shot mode)
+  ${green2("-v, --verbose")}            Show [claudish] log messages (default in interactive mode)
+  ${green2("--json")}                   Output JSON for tool integration (implies --quiet)
+  ${green2("--stdin")}                  Read prompt from stdin (large prompts / piping)
+  ${green2("--free")}                   Show only FREE models in the interactive selector
+  ${green2("--monitor")}                Monitor mode - proxy to REAL Anthropic API and log traffic
+  ${green2("--advisor")} ${yellow2('"m1,m2[:collector]"')}  Multi-model advisor replacement (implies --monitor)
+  ${green2("-y, --auto-approve")}       Skip permission prompts (--dangerously-skip-permissions)
+  ${green2("--no-auto-approve")}        Explicitly enable permission prompts (default)
+  ${green2("--dangerous")}              Pass --dangerouslyDisableSandbox to Claude Code
+  ${green2("--cost-track")}             Enable cost tracking for API usage
+  ${green2("--cost-audit")}             Show cost analysis report
+  ${green2("--cost-reset")}             Reset accumulated cost statistics
+  ${green2("--version")}                Show version information
+  ${green2("-h, --help")}               Show this help message
+  ${green2("--help-ai")}                Show AI agent usage guide (file-based patterns, sub-agents)
+  ${green2("--init")}                   Install Claudish skill in current project (.claude/skills/)
+  ${green2("--")}                       Separator: everything after passes directly to Claude Code
 
 ${h("MODEL DISCOVERY")}
-  ${green("--models")}                              Top 100 ranked (Firebase + local providers)
-  ${green("--models --provider")} ${yellow("<slug>")}                Filter the catalog to one provider
-                                          ${dim2("e.g. --provider opencode-zen, anthropic, openai")}
-  ${green("--providers")}                           Every provider + active-model count
-  ${green("-s, --models-search")} ${yellow("<query>")}             Fuzzy search: id, brand synonyms (chatgpt,
-                                          ${dim2("claude, grok), gateways (zen, oc, codex), caps")}
-  ${green("--models-top")}                          Curated recommended models (flagship + fast)
-  ${green("--probe")} ${yellow("<models...>")}                    Probe each provider in the fallback chain with
-                                          ${dim2("a real 1-token request (may incur tiny cost)")}
-  ${green("--no-probe")}                            Skip live requests, show static chain only
-  ${green("--probe-timeout")} ${yellow("<secs>")}                 Per-link timeout for live probes (default: 40)
-  ${green("--models-refresh")}                      Force refresh the slim model catalog from Firebase
-  ${green("--models-skip-update")}                  Skip the launcher catalog warm step (offline)
-  ${green("--json")}                                JSON output (with --models / --models-top / --probe)
+  ${green2("--models")}                              Top 100 ranked (Firebase + local providers)
+  ${green2("--models --provider")} ${yellow2("<slug>")}                Filter the catalog to one provider
+                                          ${dim3("e.g. --provider opencode-zen, anthropic, openai")}
+  ${green2("--providers")}                           Every provider + active-model count
+  ${green2("-s, --models-search")} ${yellow2("<query>")}             Fuzzy search: id, brand synonyms (chatgpt,
+                                          ${dim3("claude, grok), gateways (zen, oc, codex), caps")}
+  ${green2("--models-top")}                          Curated recommended models (flagship + fast)
+  ${green2("--probe")} ${yellow2("<models...>")}                    Probe each provider in the fallback chain with
+                                          ${dim3("a real 1-token request (may incur tiny cost)")}
+  ${green2("--no-probe")}                            Skip live requests, show static chain only
+  ${green2("--probe-timeout")} ${yellow2("<secs>")}                 Per-link timeout for live probes (default: 40)
+  ${green2("--models-refresh")}                      Force refresh the slim model catalog from Firebase
+  ${green2("--models-skip-update")}                  Skip the launcher catalog warm step (offline)
+  ${green2("--json")}                                JSON output (with --models / --models-top / --probe)
 
 ${h("TEAM MODE")}
-  ${green("--team")} ${yellow("<models>")}           Run multiple models in parallel (comma-separated)
-                           ${dim2('Example: --team minimax-m2.5,kimi-k2.5 "prompt"')}
-  ${green("--mode")} ${yellow("<mode>")}             Team mode: default (grid), interactive, json
-  ${green("-f, --file")} ${yellow("<path>")}         Read prompt from file (use with --team or single-shot)
+  ${green2("--team")} ${yellow2("<models>")}           Run multiple models in parallel (comma-separated)
+                           ${dim3('Example: --team minimax-m2.5,kimi-k2.5 "prompt"')}
+  ${green2("--mode")} ${yellow2("<mode>")}             Team mode: default (grid), interactive, json
+  ${green2("-f, --file")} ${yellow2("<path>")}         Read prompt from file (use with --team or single-shot)
 
-${h("MODEL MAPPING")} ${dim2("(per-role override)")}
-  ${green("--model-opus")} ${yellow("<model>")}      Model for Opus role (planning, complex tasks)
-  ${green("--model-sonnet")} ${yellow("<model>")}    Model for Sonnet role (default coding)
-  ${green("--model-haiku")} ${yellow("<model>")}     Model for Haiku role (fast tasks, background)
-  ${green("--model-subagent")} ${yellow("<model>")}  Model for sub-agents (Task tool)
+${h("MODEL MAPPING")} ${dim3("(per-role override)")}
+  ${green2("--model-opus")} ${yellow2("<model>")}      Model for Opus role (planning, complex tasks)
+  ${green2("--model-sonnet")} ${yellow2("<model>")}    Model for Sonnet role (default coding)
+  ${green2("--model-haiku")} ${yellow2("<model>")}     Model for Haiku role (fast tasks, background)
+  ${green2("--model-subagent")} ${yellow2("<model>")}  Model for sub-agents (Task tool)
 
 ${h("SUBCOMMANDS")}
-  ${green("claudish config")}                        Open the interactive config TUI (profiles,
-                                          ${dim2("providers, routing, 1Password)")}
-  ${green("claudish providers")} ${yellow("[--json]")}             Show provider credential status (no key material)
-  ${green("claudish quota")} ${yellow("[provider]")}              Show remaining quota/usage (alias: usage)
-  ${green("claudish serve")} ${yellow("--port <n> --models <p>")}  Run the Claude Desktop redirect gateway
-  ${green("claudish update")}                        Check for updates and install the latest version
-
-  ${bold3("Profiles:")}
-    ${green("claudish init")} ${yellow("[--local|--global]")}        Setup wizard - create config + first profile
-    ${green("claudish profile list")} ${yellow("[scope]")}          List all profiles (both scopes by default)
-    ${green("claudish profile add")} ${yellow("[scope]")}           Add a new profile
-    ${green("claudish profile remove")} ${yellow("[name] [scope]")}  Remove a profile
-    ${green("claudish profile use")} ${yellow("[name] [scope]")}     Set default profile
-    ${green("claudish profile show")} ${yellow("[name] [scope]")}    Show profile details
-    ${green("claudish profile edit")} ${yellow("[name] [scope]")}    Edit a profile
-    ${dim2("scope = --local (.claudish.json) | --global (~/.claudish/config.json) | (prompted)")}
-
-  ${bold3("Authentication:")}
-    ${green("claudish login")} ${yellow("[provider]")}              Login to an OAuth provider (interactive if omitted)
-    ${green("claudish logout")} ${yellow("[provider]")}             Clear OAuth credentials
-    ${dim2("Providers: gemini, kimi")}
-
-${h("1PASSWORD")} ${dim2("(SDK-based \u2014 no op CLI needed for secrets)")}
-  ${dim2("Auth via OP_SERVICE_ACCOUNT_TOKEN, or OP_ACCOUNT / onepasswordAccount config (DesktopAuth).")}
-  ${green("--op")} ${yellow("<glob> --list")}        Preview which fields a glob would import (names only)
-  ${green("--op")} ${yellow("<glob>")} ${yellow("[...args]")}      Resolve a glob into env vars, then run a session
-                           ${dim2("Inline op import requires a GLOB (self-names via field labels)")}
-                           ${dim2('Example: claudish --op "op://Jack/Keys/**" --model gpt-4o "task"')}
-  ${green("--op-env")} ${yellow("<id>")}             Load a 1Password Environment (highest-priority source)
-  ${dim2("Persistent setup (single refs, sets, environments, account): claudish config -> 1Password tab")}
+  ${green2("claudish config")}                        Open the interactive config TUI (profiles,
+                                          ${dim3("providers, routing, 1Password)")}
+  ${green2("claudish providers")} ${yellow2("[--json]")}             Show provider credential status (no key material)
+  ${green2("claudish quota")} ${yellow2("[provider]")}              Show remaining quota/usage (alias: usage)
+  ${green2("claudish serve")} ${yellow2("--port <n> --models <p>")}  Run the Claude Desktop redirect gateway
+  ${green2("claudish update")}                        Check for updates and install the latest version
+
+  ${bold4("Profiles:")}
+    ${green2("claudish init")} ${yellow2("[--local|--global]")}        Setup wizard - create config + first profile
+    ${green2("claudish profile list")} ${yellow2("[scope]")}          List all profiles (both scopes by default)
+    ${green2("claudish profile add")} ${yellow2("[scope]")}           Add a new profile
+    ${green2("claudish profile remove")} ${yellow2("[name] [scope]")}  Remove a profile
+    ${green2("claudish profile use")} ${yellow2("[name] [scope]")}     Set default profile
+    ${green2("claudish profile show")} ${yellow2("[name] [scope]")}    Show profile details
+    ${green2("claudish profile edit")} ${yellow2("[name] [scope]")}    Edit a profile
+    ${dim3("scope = --local (.claudish.json) | --global (~/.claudish/config.json) | (prompted)")}
+
+  ${bold4("Authentication:")}
+    ${green2("claudish login")} ${yellow2("[provider]")}              Login to an OAuth provider (interactive if omitted)
+    ${green2("claudish logout")} ${yellow2("[provider]")}             Clear OAuth credentials
+    ${dim3("Providers: gemini, kimi")}
+
+${h("1PASSWORD")} ${dim3("(SDK-based \u2014 no op CLI needed for secrets)")}
+  ${dim3("Auth via OP_SERVICE_ACCOUNT_TOKEN, or OP_ACCOUNT / onepasswordAccount config (DesktopAuth).")}
+  ${green2("--op")} ${yellow2("<glob> --list")}        Preview which fields a glob would import (names only)
+  ${green2("--op")} ${yellow2("<glob>")} ${yellow2("[...args]")}      Resolve a glob into env vars, then run a session
+                           ${dim3("Inline op import requires a GLOB (self-names via field labels)")}
+                           ${dim3('Example: claudish --op "op://Jack/Keys/**" --model gpt-4o "task"')}
+  ${green2("--op-env")} ${yellow2("<id>")}             Load a 1Password Environment (highest-priority source)
+  ${dim3("Persistent setup (single refs, sets, environments, account): claudish config -> 1Password tab")}
 
 ${h("CLAUDE CODE FLAG PASSTHROUGH")}
-  ${dim2("Any unrecognized flag is forwarded to Claude Code. Claudish flags can appear in any order.")}
-    ${green("claudish")} --model grok ${yellow("--agent test")} ${yellow('"task"')}        ${dim2("# --agent passes through")}
-    ${green("claudish")} --model grok ${yellow("--effort high")} --stdin ${yellow('"task"')}  ${dim2("# --effort passes, --stdin stays")}
-    ${green("claudish")} --model grok ${yellow("--permission-mode plan")} -i   ${dim2("# works in interactive too")}
-  ${dim2("Use -- when a Claude Code flag value starts with '-':")}
-    ${green("claudish")} --model grok ${green("--")} ${yellow('--system-prompt "-verbose mode" "task"')}
+  ${dim3("Any unrecognized flag is forwarded to Claude Code. Claudish flags can appear in any order.")}
+    ${green2("claudish")} --model grok ${yellow2("--agent test")} ${yellow2('"task"')}        ${dim3("# --agent passes through")}
+    ${green2("claudish")} --model grok ${yellow2("--effort high")} --stdin ${yellow2('"task"')}  ${dim3("# --effort passes, --stdin stays")}
+    ${green2("claudish")} --model grok ${yellow2("--permission-mode plan")} -i   ${dim3("# works in interactive too")}
+  ${dim3("Use -- when a Claude Code flag value starts with '-':")}
+    ${green2("claudish")} --model grok ${green2("--")} ${yellow2('--system-prompt "-verbose mode" "task"')}
 
 ${h("CUSTOM MODELS & ENDPOINTS")}
-  ${dim2("Claudish accepts ANY valid model ID from the Firebase catalog, even if not in --models:")}
-    ${green("claudish")} --model ${yellow("openrouter@your_provider/custom-model-123")} ${yellow('"task"')}
-  ${dim2("Named custom endpoints live in ~/.claudish/config.json under 'customEndpoints' and route via @:")}
-    ${green("claudish")} --model ${yellow("my-vllm@llama3.1-70b")} ${yellow('"task"')}
+  ${dim3("Claudish accepts ANY valid model ID from the Firebase catalog, even if not in --models:")}
+    ${green2("claudish")} --model ${yellow2("openrouter@your_provider/custom-model-123")} ${yellow2('"task"')}
+  ${dim3("Named custom endpoints live in ~/.claudish/config.json under 'customEndpoints' and route via @:")}
+    ${green2("claudish")} --model ${yellow2("my-vllm@llama3.1-70b")} ${yellow2('"task"')}
 
 ${h("MODES")}
-  ${green("\u2022")} ${bold3("Interactive")} ${dim2("(default):")} shows model selector, starts a persistent session
-  ${green("\u2022")} ${bold3("Single-shot")} ${dim2("(--model):")} runs one task headless and exits
+  ${green2("\u2022")} ${bold4("Interactive")} ${dim3("(default):")} shows model selector, starts a persistent session
+  ${green2("\u2022")} ${bold4("Single-shot")} ${dim3("(--model):")} runs one task headless and exits
 
 ${h("NOTES")}
-  ${yellow("\u2022")} Permission prompts are ${bold3("ENABLED")} by default (normal Claude Code behavior)
-  ${yellow("\u2022")} Use ${green("-y")} / ${green("--auto-approve")} to skip permission prompts
-  ${yellow("\u2022")} Model selector appears ONLY in interactive mode when ${green("--model")} not specified
-  ${yellow("\u2022")} ${green("--dangerous")} disables the sandbox \u2014 use with extreme caution
+  ${yellow2("\u2022")} Permission prompts are ${bold4("ENABLED")} by default (normal Claude Code behavior)
+  ${yellow2("\u2022")} Use ${green2("-y")} / ${green2("--auto-approve")} to skip permission prompts
+  ${yellow2("\u2022")} Model selector appears ONLY in interactive mode when ${green2("--model")} not specified
+  ${yellow2("\u2022")} ${green2("--dangerous")} disables the sandbox \u2014 use with extreme caution
 
 ${h("ENVIRONMENT VARIABLES")}
-  ${dim2("Claudish auto-loads a .env file from the current directory.")}
+  ${dim3("Claudish auto-loads a .env file from the current directory.")}
 
-  ${bold3("Claude Code installation:")}
+  ${bold4("Claude Code installation:")}
   ${blue("CLAUDE_PATH")}                     Custom path to Claude Code binary
-                                  ${dim2("Search: CLAUDE_PATH -> ~/.claude/local/claude -> PATH")}
+                                  ${dim3("Search: CLAUDE_PATH -> ~/.claude/local/claude -> PATH")}
 
-  ${bold3("API keys")} ${dim2("(at least one required for cloud models):")}
+  ${bold4("API keys")} ${dim3("(at least one required for cloud models):")}
   ${blue("OPENROUTER_API_KEY")}              OpenRouter (default backend)
-  ${blue("GEMINI_API_KEY")}                  Google Gemini ${dim2("(g@, gemini@; alias GOOGLE_API_KEY)")}
-  ${blue("OPENAI_API_KEY")}                  OpenAI ${dim2("(oai@)")}
-  ${blue("OPENAI_CODEX_API_KEY")}            OpenAI Codex / Responses API ${dim2("(cx@, codex@)")}
-  ${blue("XAI_API_KEY")}                     xAI / Grok ${dim2("(x-ai@, grok@)")}
-  ${blue("MINIMAX_API_KEY")}                 MiniMax ${dim2("(mm@, mmax@)")}
-  ${blue("MINIMAX_CODING_API_KEY")}          MiniMax Coding Plan ${dim2("(mmc@)")}
-  ${blue("MOONSHOT_API_KEY")}                Kimi / Moonshot ${dim2("(kimi@, moon@; alias KIMI_API_KEY)")}
-  ${blue("KIMI_CODING_API_KEY")}             Kimi Coding Plan ${dim2("(kc@)")}
-  ${blue("ZHIPU_API_KEY")}                   GLM / Zhipu ${dim2("(glm@, zhipu@; alias GLM_API_KEY)")}
-  ${blue("GLM_CODING_API_KEY")}              GLM Coding Plan ${dim2("(gc@; alias ZAI_CODING_API_KEY)")}
-  ${blue("ZAI_API_KEY")}                     Z.AI ${dim2("(z-ai@, zai@)")}
-  ${blue("DEEPSEEK_API_KEY")}                DeepSeek ${dim2("(ds@)")}
-  ${blue("SAKANA_API_KEY")}                  Sakana Fugu ${dim2("(sakana@, fugu@)")}
-  ${blue("SAKANA_SUBSCRIPTION_API_KEY")}     Sakana Fugu Subscription ${dim2("(sc@; separate subscription key)")}
-  ${blue("OLLAMA_API_KEY")}                  OllamaCloud ${dim2("(oc@, llama@)")}
-  ${blue("OPENCODE_API_KEY")}                OpenCode Zen ${dim2("(zen@; optional - free models work without it)")}
-  ${blue("POE_API_KEY")}                     Poe ${dim2("(poe@)")}
-  ${blue("LITELLM_API_KEY")}                 LiteLLM ${dim2("(litellm@, ll@; needs LITELLM_BASE_URL)")}
-  ${blue("VERTEX_API_KEY")}                  Vertex AI Express ${dim2("(v@)")}
-  ${blue("VERTEX_PROJECT")}                  Vertex AI project ID ${dim2("(OAuth mode, v@)")}
-  ${blue("VERTEX_LOCATION")}                 Vertex AI region ${dim2("(default: us-central1)")}
+  ${blue("GEMINI_API_KEY")}                  Google Gemini ${dim3("(g@, gemini@; alias GOOGLE_API_KEY)")}
+  ${blue("OPENAI_API_KEY")}                  OpenAI ${dim3("(oai@)")}
+  ${blue("OPENAI_CODEX_API_KEY")}            OpenAI Codex / Responses API ${dim3("(cx@, codex@)")}
+  ${blue("XAI_API_KEY")}                     xAI / Grok ${dim3("(x-ai@, grok@)")}
+  ${blue("MINIMAX_API_KEY")}                 MiniMax ${dim3("(mm@, mmax@)")}
+  ${blue("MINIMAX_CODING_API_KEY")}          MiniMax Coding Plan ${dim3("(mmc@)")}
+  ${blue("MOONSHOT_API_KEY")}                Kimi / Moonshot ${dim3("(kimi@, moon@; alias KIMI_API_KEY)")}
+  ${blue("KIMI_CODING_API_KEY")}             Kimi Coding Plan ${dim3("(kc@)")}
+  ${blue("ZHIPU_API_KEY")}                   GLM / Zhipu ${dim3("(glm@, zhipu@; alias GLM_API_KEY)")}
+  ${blue("GLM_CODING_API_KEY")}              GLM Coding Plan ${dim3("(gc@; alias ZAI_CODING_API_KEY)")}
+  ${blue("ZAI_API_KEY")}                     Z.AI ${dim3("(z-ai@, zai@)")}
+  ${blue("DEEPSEEK_API_KEY")}                DeepSeek ${dim3("(ds@)")}
+  ${blue("SAKANA_API_KEY")}                  Sakana Fugu ${dim3("(sakana@, fugu@)")}
+  ${blue("SAKANA_SUBSCRIPTION_API_KEY")}     Sakana Fugu Subscription ${dim3("(sc@; separate subscription key)")}
+  ${blue("OLLAMA_API_KEY")}                  OllamaCloud ${dim3("(oc@, llama@)")}
+  ${blue("OPENCODE_API_KEY")}                OpenCode Zen ${dim3("(zen@; optional - free models work without it)")}
+  ${blue("POE_API_KEY")}                     Poe ${dim3("(poe@)")}
+  ${blue("LITELLM_API_KEY")}                 LiteLLM ${dim3("(litellm@, ll@; needs LITELLM_BASE_URL)")}
+  ${blue("VERTEX_API_KEY")}                  Vertex AI Express ${dim3("(v@)")}
+  ${blue("VERTEX_PROJECT")}                  Vertex AI project ID ${dim3("(OAuth mode, v@)")}
+  ${blue("VERTEX_LOCATION")}                 Vertex AI region ${dim3("(default: us-central1)")}
   ${blue("ANTHROPIC_API_KEY")}               Placeholder (prevents Claude Code dialog)
   ${blue("ANTHROPIC_AUTH_TOKEN")}            Placeholder (prevents Claude Code login screen)
 
-  ${bold3("Custom / base-URL overrides:")}
+  ${bold4("Custom / base-URL overrides:")}
   ${blue("GEMINI_BASE_URL")}                 Custom Gemini endpoint
   ${blue("OPENAI_BASE_URL")}                 Custom OpenAI / Azure endpoint
   ${blue("MINIMAX_BASE_URL")}                Custom MiniMax endpoint
-  ${blue("MOONSHOT_BASE_URL")}               Custom Kimi / Moonshot endpoint ${dim2("(alias KIMI_BASE_URL)")}
-  ${blue("ZHIPU_BASE_URL")}                  Custom GLM / Zhipu endpoint ${dim2("(alias GLM_BASE_URL)")}
-  ${blue("SAKANA_BASE_URL")}                 Custom Sakana endpoint ${dim2("(default: https://api.sakana.ai)")}
-  ${blue("LITELLM_BASE_URL")}                LiteLLM gateway base URL ${dim2("(required for ll@)")}
-  ${blue("OLLAMACLOUD_BASE_URL")}            OllamaCloud ${dim2("(default: https://ollama.com)")}
-  ${blue("OPENCODE_BASE_URL")}               OpenCode Zen ${dim2("(default: https://opencode.ai/zen)")}
-
-  ${bold3("Local providers:")}
-  ${blue("OLLAMA_BASE_URL")}                 Ollama server ${dim2("(default: http://localhost:11434; alias OLLAMA_HOST)")}
-  ${blue("LMSTUDIO_BASE_URL")}               LM Studio server ${dim2("(default: http://localhost:1234)")}
-  ${blue("VLLM_BASE_URL")}                   vLLM server ${dim2("(default: http://localhost:8000)")}
-  ${blue("MLX_BASE_URL")}                    MLX server ${dim2("(default: http://127.0.0.1:8080)")}
-
-  ${bold3("Claudish settings:")}
-  ${blue("CLAUDISH_MODEL")}                  Default model ${dim2("(default: openai/gpt-5.3)")}
-  ${blue("CLAUDISH_DEFAULT_PROVIDER")}       Fallback provider for bare names ${dim2("(see --default-provider)")}
+  ${blue("MOONSHOT_BASE_URL")}               Custom Kimi / Moonshot endpoint ${dim3("(alias KIMI_BASE_URL)")}
+  ${blue("ZHIPU_BASE_URL")}                  Custom GLM / Zhipu endpoint ${dim3("(alias GLM_BASE_URL)")}
+  ${blue("SAKANA_BASE_URL")}                 Custom Sakana endpoint ${dim3("(default: https://api.sakana.ai)")}
+  ${blue("LITELLM_BASE_URL")}                LiteLLM gateway base URL ${dim3("(required for ll@)")}
+  ${blue("OLLAMACLOUD_BASE_URL")}            OllamaCloud ${dim3("(default: https://ollama.com)")}
+  ${blue("OPENCODE_BASE_URL")}               OpenCode Zen ${dim3("(default: https://opencode.ai/zen)")}
+
+  ${bold4("Local providers:")}
+  ${blue("OLLAMA_BASE_URL")}                 Ollama server ${dim3("(default: http://localhost:11434; alias OLLAMA_HOST)")}
+  ${blue("LMSTUDIO_BASE_URL")}               LM Studio server ${dim3("(default: http://localhost:1234)")}
+  ${blue("VLLM_BASE_URL")}                   vLLM server ${dim3("(default: http://localhost:8000)")}
+  ${blue("MLX_BASE_URL")}                    MLX server ${dim3("(default: http://127.0.0.1:8080)")}
+
+  ${bold4("Claudish settings:")}
+  ${blue("CLAUDISH_MODEL")}                  Default model ${dim3("(default: openai/gpt-5.3)")}
+  ${blue("CLAUDISH_DEFAULT_PROVIDER")}       Fallback provider for bare names ${dim3("(see --default-provider)")}
   ${blue("CLAUDISH_PORT")}                   Default proxy port
   ${blue("CLAUDISH_CONTEXT_WINDOW")}         Override context window size
   ${blue("CLAUDISH_DIAG_MODE")}              Diagnostic output: auto / logfile / off
-  ${blue("CLAUDISH_DEBUG")}                  Always enable debug logging: 1 / true ${dim2("(same as -d)")}
-  ${blue("CLAUDISH_ANTHROPIC_API_BILLING")}  Bill native Claude to your API key ${dim2("(see --anthropic-api-billing)")}
+  ${blue("CLAUDISH_DEBUG")}                  Always enable debug logging: 1 / true ${dim3("(same as -d)")}
+  ${blue("CLAUDISH_ANTHROPIC_API_BILLING")}  Bill native Claude to your API key ${dim3("(see --anthropic-api-billing)")}
   ${blue("CLAUDISH_MCP_TOOLS")}              MCP tool gating: all / low-level / agentic / channel
   ${blue("CLAUDISH_MODEL_OPUS")}             Override model for Opus role
   ${blue("CLAUDISH_MODEL_SONNET")}           Override model for Sonnet role
@@ -65451,47 +65947,47 @@ ${h("ENVIRONMENT VARIABLES")}
   ${blue("CLAUDISH_MODEL_SUBAGENT")}         Override model for sub-agents
   ${blue("NO_COLOR")}                        Set to disable colored output
 
-  ${bold3("1Password auth:")}
+  ${bold4("1Password auth:")}
   ${blue("OP_SERVICE_ACCOUNT_TOKEN")}        Service-account token (preferred for headless)
-  ${blue("OP_ACCOUNT")}                      Account URL for DesktopAuth ${dim2("(e.g. my-team.1password.com)")}
+  ${blue("OP_ACCOUNT")}                      Account URL for DesktopAuth ${dim3("(e.g. my-team.1password.com)")}
 
 ${h("EXAMPLES")}
-  ${dim2("# Interactive (default) - model selector")}
-  ${green("claudish")}
-  ${green("claudish")} --free                          ${dim2("# only FREE models")}
+  ${dim3("# Interactive (default) - model selector")}
+  ${green2("claudish")}
+  ${green2("claudish")} --free                          ${dim3("# only FREE models")}
 
-  ${dim2("# Explicit provider routing")}
-  ${green("claudish")} --model ${magenta("google@gemini-3-pro")} ${yellow('"implement auth"')}
-  ${green("claudish")} --model ${magenta("oai@gpt-5.3")} ${yellow('"add tests for login"')}
-  ${green("claudish")} --model ${magenta("openrouter@deepseek/deepseek-r1")} ${yellow('"unknown vendor"')}
+  ${dim3("# Explicit provider routing")}
+  ${green2("claudish")} --model ${magenta("google@gemini-3-pro")} ${yellow2('"implement auth"')}
+  ${green2("claudish")} --model ${magenta("oai@gpt-5.3")} ${yellow2('"add tests for login"')}
+  ${green2("claudish")} --model ${magenta("openrouter@deepseek/deepseek-r1")} ${yellow2('"unknown vendor"')}
 
-  ${dim2("# Native auto-detection (provider inferred from model name)")}
-  ${green("claudish")} --model ${yellow("gpt-4o")} ${yellow('"routes to OpenAI"')}
-  ${green("claudish")} --model ${yellow("gemini-2.5-pro")} ${yellow('"routes to Google"')}
+  ${dim3("# Native auto-detection (provider inferred from model name)")}
+  ${green2("claudish")} --model ${yellow2("gpt-4o")} ${yellow2('"routes to OpenAI"')}
+  ${green2("claudish")} --model ${yellow2("gemini-2.5-pro")} ${yellow2('"routes to Google"')}
 
-  ${dim2("# Per-role model mapping")}
-  ${green("claudish")} --model-opus ${magenta("oai@gpt-5.3")} --model-sonnet ${magenta("google@gemini-3-pro")}
+  ${dim3("# Per-role model mapping")}
+  ${green2("claudish")} --model-opus ${magenta("oai@gpt-5.3")} --model-sonnet ${magenta("google@gemini-3-pro")}
 
-  ${dim2("# stdin for large prompts (diffs, code review)")}
-  ${dim2("git diff |")} ${green("claudish")} --stdin --model ${magenta("oai@gpt-5.3")} ${yellow('"Review these changes"')}
+  ${dim3("# stdin for large prompts (diffs, code review)")}
+  ${dim3("git diff |")} ${green2("claudish")} --stdin --model ${magenta("oai@gpt-5.3")} ${yellow2('"Review these changes"')}
 
-  ${dim2("# Local models with concurrency control")}
-  ${green("claudish")} --model ${magenta("ollama@llama3.2:3")} ${yellow('"3 concurrent requests"')}
-  ${green("claudish")} --model ${magenta("lms@qwen2.5-coder")} ${yellow('"LM Studio shortcut"')}
-  ${green("claudish")} --model ${yellow('"http://localhost:8000/mistral"')} ${yellow('"any OpenAI-compatible URL"')}
+  ${dim3("# Local models with concurrency control")}
+  ${green2("claudish")} --model ${magenta("ollama@llama3.2:3")} ${yellow2('"3 concurrent requests"')}
+  ${green2("claudish")} --model ${magenta("lms@qwen2.5-coder")} ${yellow2('"LM Studio shortcut"')}
+  ${green2("claudish")} --model ${yellow2('"http://localhost:8000/mistral"')} ${yellow2('"any OpenAI-compatible URL"')}
 
-  ${dim2("# Autonomous (no prompts, no sandbox) \u2014 use with caution")}
-  ${green("claudish")} -y --dangerous ${yellow('"refactor entire codebase"')}
+  ${dim3("# Autonomous (no prompts, no sandbox) \u2014 use with caution")}
+  ${green2("claudish")} -y --dangerous ${yellow2('"refactor entire codebase"')}
 
 ${h("MORE INFO")}
-  ${dim2("GitHub:")}     ${blue("https://github.com/MadAppGang/claude-code")}
-  ${dim2("OpenRouter:")} ${blue("https://openrouter.ai")}
+  ${dim3("GitHub:")}     ${blue("https://github.com/MadAppGang/claude-code")}
+  ${dim3("OpenRouter:")} ${blue("https://openrouter.ai")}
 `);
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join24(__dirname3, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync20(guidePath, "utf-8");
+    const guidePath = join27(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync21(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -65507,10 +66003,10 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join24(cwd, ".claude");
-  const skillsDir = join24(claudeDir, "skills");
-  const claudishSkillDir = join24(skillsDir, "claudish-usage");
-  const skillFile = join24(claudishSkillDir, "SKILL.md");
+  const claudeDir = join27(cwd, ".claude");
+  const skillsDir = join27(claudeDir, "skills");
+  const claudishSkillDir = join27(skillsDir, "claudish-usage");
+  const skillFile = join27(claudishSkillDir, "SKILL.md");
   if (existsSync21(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
@@ -65518,7 +66014,7 @@ async function initializeClaudishSkill() {
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join24(__dirname3, "../skills/claudish-usage/SKILL.md");
+  const sourceSkillPath = join27(__dirname3, "../skills/claudish-usage/SKILL.md");
   if (!existsSync21(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
@@ -65609,7 +66105,7 @@ var init_cli = __esm(() => {
   init_routing_rules();
   init_provider_resolver();
   __filename3 = fileURLToPath2(import.meta.url);
-  __dirname3 = dirname8(__filename3);
+  __dirname3 = dirname9(__filename3);
 });
 
 // src/update-checker.ts
@@ -65621,24 +66117,24 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync21, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
-import { homedir as homedir23, platform as platform2, tmpdir } from "os";
-import { join as join25 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync22, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
+import { homedir as homedir26, platform as platform2, tmpdir } from "os";
+import { join as join28 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join25(homedir23(), "AppData", "Local");
-    cacheDir = join25(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join28(homedir26(), "AppData", "Local");
+    cacheDir = join28(localAppData, "claudish");
   } else {
-    cacheDir = join25(homedir23(), ".cache", "claudish");
+    cacheDir = join28(homedir26(), ".cache", "claudish");
   }
   try {
     if (!existsSync22(cacheDir)) {
       mkdirSync14(cacheDir, { recursive: true });
     }
-    return join25(cacheDir, "update-check.json");
+    return join28(cacheDir, "update-check.json");
   } catch {
-    return join25(tmpdir(), "claudish-update-check.json");
+    return join28(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
@@ -65647,7 +66143,7 @@ function readCache() {
     if (!existsSync22(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync21(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync22(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -66518,16 +67014,22 @@ function localBaseUrl(catalogName) {
   }
   return (def.baseUrl || "").replace(/\/+$/, "") || null;
 }
+function isHtmlResponse(res) {
+  const contentType = res.headers.get("content-type") ?? "";
+  return /\btext\/html\b|\bapplication\/xhtml\+xml\b/i.test(contentType);
+}
 async function pingLocalProvider(catalogName, timeoutMs = PING_TIMEOUT_MS) {
   const base = localBaseUrl(catalogName);
   const path2 = HEALTH_PATH[catalogName];
   if (!base || !path2)
     return "unknown";
   try {
-    await fetch(`${base}${path2}`, {
+    const res = await fetch(`${base}${path2}`, {
       method: "GET",
       signal: AbortSignal.timeout(timeoutMs)
     });
+    if (res.ok && isHtmlResponse(res))
+      return "down";
     return "running";
   } catch {
     return "down";
@@ -66549,15 +67051,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync17 } from "fs";
-import { homedir as homedir24 } from "os";
-import { dirname as dirname9, join as join26 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
+import { homedir as homedir27 } from "os";
+import { dirname as dirname10, join as join29 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   if (!existsSync23(path2))
     return null;
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync22(path2, "utf-8"));
+    raw2 = JSON.parse(readFileSync23(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -66566,7 +67068,7 @@ function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   return raw2;
 }
 function writeProbeModelsCache(data, path2 = PROBE_MODELS_CACHE_PATH) {
-  mkdirSync15(dirname9(path2), { recursive: true });
+  mkdirSync15(dirname10(path2), { recursive: true });
   writeFileSync17(path2, JSON.stringify(data), "utf-8");
 }
 function isCacheFresh(data, ttlMs = CACHE_TTL_MS4) {
@@ -66686,7 +67188,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 = join26(homedir24(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join29(homedir27(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -73026,12 +73528,12 @@ import {
   existsSync as existsSync24,
   mkdirSync as mkdirSync16,
   openSync as openSync5,
-  readFileSync as readFileSync23,
+  readFileSync as readFileSync24,
   unlinkSync as unlinkSync9,
   writeFileSync as writeFileSync18
 } from "fs";
-import { homedir as homedir25, tmpdir as tmpdir2 } from "os";
-import { join as join27 } from "path";
+import { homedir as homedir28, tmpdir as tmpdir2 } from "os";
+import { join as join30 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -73066,14 +73568,14 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join27(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join30(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
   }
   return "/etc/claude-code/managed-settings.json";
 }
-function managedSettingsForcesClaudeAi(readFile = readFileSync23) {
+function managedSettingsForcesClaudeAi(readFile = readFileSync24) {
   try {
     const raw2 = readFile(managedSettingsPath(), "utf-8");
     const parsed = JSON.parse(raw2);
@@ -73087,9 +73589,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join27(homeDir, ".claudish");
+  const claudishDir = join30(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join27(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join30(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -73212,13 +73714,13 @@ process.stdin.on('end', () => {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join27(homeDir, ".claudish");
+  const claudishDir = join30(homeDir, ".claudish");
   try {
     mkdirSync16(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join27(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join27(claudishDir, `tokens-${port}.json`);
+  const tempPath = join30(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join30(claudishDir, `tokens-${port}.json`);
   let statusCommand;
   if (isWindows2()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
@@ -73262,7 +73764,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine, proxy
     if (userSettingsValue.trimStart().startsWith("{")) {
       userSettings = JSON.parse(userSettingsValue);
     } else {
-      const rawUserSettings = readFileSync23(userSettingsValue, "utf-8");
+      const rawUserSettings = readFileSync24(userSettingsValue, "utf-8");
       userSettings = JSON.parse(rawUserSettings);
     }
     userSettings.statusLine = statusLine;
@@ -73433,8 +73935,8 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir25();
-    const localPath = isWindows2() ? join27(home, ".claude", "local", "claude.exe") : join27(home, ".claude", "local", "claude");
+    const home = homedir28();
+    const localPath = isWindows2() ? join30(home, ".claude", "local", "claude.exe") : join30(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -73518,16 +74020,16 @@ async function findClaudeBinary() {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir25();
-  const localPath = isWindows3 ? join27(home, ".claude", "local", "claude.exe") : join27(home, ".claude", "local", "claude");
+  const home = homedir28();
+  const localPath = isWindows3 ? join30(home, ".claude", "local", "claude.exe") : join30(home, ".claude", "local", "claude");
   if (existsSync24(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join27(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join27(home, ".npm-global", "claude.cmd"),
-      join27(home, "node_modules", ".bin", "claude.cmd")
+      join30(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join30(home, ".npm-global", "claude.cmd"),
+      join30(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
       if (existsSync24(path2)) {
@@ -73538,11 +74040,11 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join27(home, ".npm-global/bin/claude"),
-      join27(home, ".local/bin/claude"),
-      join27(home, "node_modules/.bin/claude"),
+      join30(home, ".npm-global/bin/claude"),
+      join30(home, ".local/bin/claude"),
+      join30(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join27(home, "../usr/bin/claude")
+      join30(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
       if (existsSync24(path2)) {
@@ -73603,17 +74105,17 @@ __export(exports_diag_output, {
   LogFileDiagOutput: () => LogFileDiagOutput
 });
 import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync17, unlinkSync as unlinkSync10, writeFileSync as writeFileSync19 } from "fs";
-import { homedir as homedir26 } from "os";
-import { join as join28 } from "path";
+import { homedir as homedir29 } from "os";
+import { join as join31 } from "path";
 function getClaudishDir() {
-  const dir = join28(homedir26(), ".claudish");
+  const dir = join31(homedir29(), ".claudish");
   try {
     mkdirSync17(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join28(getClaudishDir(), `diag-${process.pid}.log`);
+  return join31(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -73824,9 +74326,9 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn5 } from "child_process";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync24, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname10, join as join29 } from "path";
+import { dirname as dirname11, join as join32 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveRouteInfo(modelId) {
@@ -73919,21 +74421,21 @@ function buildPaneHeader(model, prompt, bg) {
 }
 function findMagmuxBinary() {
   const thisFile = fileURLToPath3(import.meta.url);
-  const thisDir = dirname10(thisFile);
-  const pkgRoot = join29(thisDir, "..");
+  const thisDir = dirname11(thisFile);
+  const pkgRoot = join32(thisDir, "..");
   const platform3 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join29(pkgRoot, "native", `magmux-${platform3}-${arch}`);
+  const bundledMagmux = join32(pkgRoot, "native", `magmux-${platform3}-${arch}`);
   if (existsSync25(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform3}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join29(searchDir, "node_modules", pkgName, "bin", "magmux");
+      const candidate = join32(searchDir, "node_modules", pkgName, "bin", "magmux");
       if (existsSync25(candidate))
         return candidate;
-      const parent = dirname10(searchDir);
+      const parent = dirname11(searchDir);
       if (parent === searchDir)
         break;
       searchDir = parent;
@@ -74037,9 +74539,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 = join29(sessionPath, "gridfile.txt");
-  const prompt = readFileSync24(join29(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync24(join29(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join32(sessionPath, "gridfile.txt");
+  const prompt = readFileSync25(join32(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync25(join32(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -74070,7 +74572,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 = join29(sessionPath, "status.json");
+  const statusPath = join32(sessionPath, "status.json");
   writeFileSync20(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
@@ -74094,8 +74596,8 @@ var init_team_grid = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync26, readFileSync as readFileSync25 } from "fs";
-import { join as join30, resolve as resolve4 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync26 } from "fs";
+import { join as join33, resolve as resolve4 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -74228,6 +74730,7 @@ var isStatsCommand = firstPositional === "stats";
 var isConfigCommand = firstPositional === "config";
 var isServeCommand = firstPositional === "serve";
 var isProvidersCommand = firstPositional === "providers";
+var isBehaviorCommand = firstPositional === "behavior";
 var isLoginCommand = firstPositional === "login";
 var isLogoutCommand = firstPositional === "logout";
 var isQuotaCommand = firstPositional === "quota" || firstPositional === "usage";
@@ -74243,6 +74746,12 @@ if (isMcpMode) {
     console.error(`[claudish serve] ${e instanceof Error ? e.message : String(e)}`);
     process.exit(1);
   }));
+} else if (isBehaviorCommand) {
+  const behaviorArgIndex = args.indexOf("behavior");
+  Promise.resolve().then(() => (init_behavior_command(), exports_behavior_command)).then((m) => m.behaviorCommand(args.slice(behaviorArgIndex + 1)).catch((e) => {
+    console.error(`[claudish behavior] ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+  }));
 } else if (isProvidersCommand) {
   const json2 = args.includes("--json");
   Promise.resolve().then(() => (init_providers_command(), exports_providers_command)).then((m) => m.providersCommand({ json: json2 }).catch((e) => {
@@ -74329,14 +74838,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync25(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync26(cliConfig.inputFile, "utf-8");
       }
       if (!prompt.trim()) {
         console.error("Error: --team requires a prompt (positional args or -f <file>)");
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join30(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join33(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);
@@ -74346,9 +74855,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join30(sessionPath, `response-${anonId}.md`);
+          const responsePath = join33(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync25(responsePath, "utf-8").trim();
+            const raw2 = readFileSync26(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {