claudish 7.66.1 → 7.67.1

package/dist/index.js

@@ -731,7 +731,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.66.1";
+var VERSION = "7.67.1";
 
 // src/logger.ts
 var exports_logger = {};
@@ -27562,6 +27562,7 @@ __export(exports_profile_config, {
   loadConfig: () => loadConfig,
   loadLocalConfig: () => loadLocalConfig,
   localConfigExists: () => localConfigExists,
+  readProOnUltracode: () => readProOnUltracode,
   removeApiKey: () => removeApiKey,
   removeEndpoint: () => removeEndpoint,
   saveConfig: () => saveConfig,
@@ -27650,6 +27651,9 @@ function loadConfig() {
     if (config2.behavior !== undefined) {
       merged.behavior = config2.behavior;
     }
+    if (config2.proOnUltracode !== undefined) {
+      merged.proOnUltracode = config2.proOnUltracode;
+    }
     return merged;
   } catch (error46) {
     console.error(`Warning: Failed to load config, using defaults: ${error46}`);
@@ -27685,6 +27689,19 @@ function getLocalConfigPath() {
 function localConfigExists() {
   return existsSync5(getLocalConfigPath());
 }
+function readProOnUltracode(paths = defaultScopedConfigPaths) {
+  for (const pathFn of [paths.project, paths.global]) {
+    try {
+      const path = pathFn();
+      if (!existsSync5(path))
+        continue;
+      const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+      if (typeof parsed?.proOnUltracode === "boolean")
+        return parsed.proOnUltracode;
+    } catch {}
+  }
+  return;
+}
 function isProjectDirectory() {
   const cwd = process.cwd();
   return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync5(join7(cwd, f)));
@@ -27968,7 +27985,7 @@ function disableLocalProvider(providerName) {
   }
   saveConfig(config2);
 }
-var CONFIG_DIR, CONFIG_FILE, LOCAL_CONFIG_FILENAME = ".claudish.json", DEFAULT_CONFIG;
+var CONFIG_DIR, CONFIG_FILE, LOCAL_CONFIG_FILENAME = ".claudish.json", DEFAULT_CONFIG, defaultScopedConfigPaths;
 var init_profile_config = __esm(() => {
   CONFIG_DIR = join7(homedir7(), ".claudish");
   CONFIG_FILE = join7(CONFIG_DIR, "config.json");
@@ -27985,6 +28002,10 @@ var init_profile_config = __esm(() => {
       }
     }
   };
+  defaultScopedConfigPaths = {
+    global: () => activeConfigFile(),
+    project: () => getLocalConfigPath()
+  };
 });
 
 // src/providers/runtime-providers.ts
@@ -28149,6 +28170,24 @@ function lookupFamilyDefaultVariant(familyId, provider, cachePath) {
   }
   return;
 }
+function lookupVariantPresets(baseModelId, provider, cachePath) {
+  const cache2 = readAllModelsCache(cachePath);
+  if (!cache2)
+    return [];
+  const wanted = stripVendorPrefix(baseModelId.toLowerCase());
+  const found = [];
+  for (const entry of cache2.entries) {
+    const rv = entry.routeVariant;
+    if (!rv?.preset || !rv.baseModelId)
+      continue;
+    if (stripVendorPrefix(rv.baseModelId.toLowerCase()) !== wanted)
+      continue;
+    if (provider !== undefined && rv.provider !== provider)
+      continue;
+    found.push({ modelId: entry.modelId, preset: rv.preset, provider: rv.provider });
+  }
+  return found;
+}
 function lookupModelCapabilities(modelId, cachePath) {
   const entry = findCacheEntry(modelId, cachePath);
   if (!entry)
@@ -28177,6 +28216,9 @@ function isSubscriptionPlan(provider, cachePath) {
     return false;
   return cache2.entries.some((e) => e.subscriptionPlans?.includes(provider));
 }
+function stripVendorPrefix(lowerId) {
+  return lowerId.includes("/") ? lowerId.substring(lowerId.lastIndexOf("/") + 1) : lowerId;
+}
 function findCacheEntry(modelId, cachePath) {
   if (modelId.includes("@")) {
     throw new Error(`model-catalog lookup received provider-routed ID "${modelId}" \u2014 callers must strip the "@" prefix before calling`);
@@ -28185,7 +28227,7 @@ function findCacheEntry(modelId, cachePath) {
   if (!cache2 || cache2.entries.length === 0)
     return;
   const lower = modelId.toLowerCase();
-  const unprefixed = lower.includes("/") ? lower.substring(lower.lastIndexOf("/") + 1) : lower;
+  const unprefixed = stripVendorPrefix(lower);
   for (const entry of cache2.entries) {
     const entryId = entry.modelId.toLowerCase();
     const exactMatch = entryId === unprefixed || entryId === lower;
@@ -28226,8 +28268,10 @@ function truncateToolName(name, maxLength) {
   log(`[ToolName] Truncated: "${name}" -> "${truncated}" (${name.length} -> ${truncated.length} chars)`);
   return truncated;
 }
+var TOOL_NAME_SOURCE = "[A-Za-z_][A-Za-z0-9_.-]{0,63}", TOOL_NAME_SHAPE;
 var init_tool_name_utils = __esm(() => {
   init_logger();
+  TOOL_NAME_SHAPE = new RegExp(`^${TOOL_NAME_SOURCE}$`);
 });
 
 // src/handlers/shared/format/openai-messages.ts
@@ -28658,6 +28702,8 @@ class BaseAPIFormat {
     return request;
   }
   clampToAdvertisedEffort(requested, reasoning) {
+    if (this.pinnedEffort)
+      return this.pinnedEffort;
     const advertised = (reasoning.efforts ?? []).filter(isEffortLevel);
     if (advertised.length === 0) {
       return isEffortLevel(reasoning.defaultEffort) ? reasoning.defaultEffort : undefined;
@@ -28699,7 +28745,13 @@ class BaseAPIFormat {
         return 8192;
     }
   }
+  pinnedEffort;
+  setEffortOverride(level) {
+    this.pinnedEffort = level;
+  }
   resolveEffortLevel(originalRequest) {
+    if (this.pinnedEffort)
+      return this.pinnedEffort;
     const lvl = originalRequest?.output_config?.effort;
     if (typeof lvl === "string") {
       const lower = lvl.toLowerCase();
@@ -29539,9 +29591,32 @@ function filterIdentity(content) {
 }
 
 // src/handlers/shared/tool-call-recovery.ts
-function extractToolCallsFromText(text) {
+function hasExtractableFunctionTag(text) {
+  return FUNCTION_TAG_PRESENT.test(text);
+}
+function keepOnlyRealTools(extracted, knownToolNames) {
+  const kept = [];
+  for (const call of extracted) {
+    if (!TOOL_NAME_SHAPE.test(call.name)) {
+      log(`[ToolRecovery] Dropped extracted call: name is not an identifier: ${JSON.stringify(call.name.slice(0, 120))}`);
+      continue;
+    }
+    if (!knownToolNames || knownToolNames.length === 0) {
+      kept.push(call);
+      continue;
+    }
+    const canonical = knownToolNames.find((t) => t.toLowerCase() === call.name.toLowerCase());
+    if (!canonical) {
+      log(`[ToolRecovery] Dropped extracted call for unadvertised tool: ${call.name}`);
+      continue;
+    }
+    kept.push(canonical === call.name ? call : { ...call, name: canonical });
+  }
+  return kept;
+}
+function extractToolCallsFromText(text, knownToolNames) {
   const extracted = [];
-  const qwenPattern = /<function=([^>]+)>([\s\S]*?)(?=<function=|$)/gi;
+  const qwenPattern = new RegExp(FUNCTION_TAG_SOURCE, "gi");
   let match;
   while ((match = qwenPattern.exec(text)) !== null) {
     const funcName = match[1];
@@ -29635,7 +29710,7 @@ function extractToolCallsFromText(text) {
       }
     } catch (e) {}
   }
-  const knownTools = [
+  const knownTools = knownToolNames && knownToolNames.length > 0 ? knownToolNames : [
     "Task",
     "Read",
     "Write",
@@ -29743,7 +29818,7 @@ function extractToolCallsFromText(text) {
       }
     }
   }
-  return extracted;
+  return keepOnlyRealTools(extracted, knownToolNames);
 }
 function inferMissingParameters(toolName2, args, missingParams, context) {
   const inferred = { ...args };
@@ -29908,8 +29983,12 @@ function validateAndRepairToolCall(toolName2, argsStr, toolSchemas, textContent)
   }
   return { valid: false, args: repairedArgs, repaired: false, missingParams: stillMissing };
 }
+var FUNCTION_TAG_SOURCE, FUNCTION_TAG_PRESENT;
 var init_tool_call_recovery = __esm(() => {
+  init_tool_name_utils();
   init_logger();
+  FUNCTION_TAG_SOURCE = `<function=(${TOOL_NAME_SOURCE})>([\\s\\S]*?)(?=<function=|$)`;
+  FUNCTION_TAG_PRESENT = new RegExp(`<function=${TOOL_NAME_SOURCE}>`);
 });
 
 // src/handlers/shared/web-search-detector.ts
@@ -30052,7 +30131,10 @@ data: ${JSON.stringify(d)}
             const preview = state.accumulatedText.slice(0, 500).replace(/\n/g, "\\n");
             log(`[Streaming] Accumulated text (${state.accumulatedText.length} chars): ${preview}...`);
           }
-          const textToolCalls = extractToolCallsFromText(state.accumulatedText);
+          const textToolCalls = state.tools.size > 0 ? [] : extractToolCallsFromText(state.accumulatedText, toolSchemas?.map((t) => t?.name).filter((n) => !!n));
+          if (state.tools.size > 0 && state.accumulatedText.length > 0) {
+            log(`[Streaming] Skipping text-based tool extraction: ${state.tools.size} structured tool call(s) already present`);
+          }
           log(`[Streaming] Text-based tool calls found: ${textToolCalls.length}`);
           if (textToolCalls.length > 0) {
             log(`[Streaming] Found ${textToolCalls.length} text-based tool call(s), converting to structured format`);
@@ -30259,7 +30341,7 @@ data: ${JSON.stringify(d)}
                   }
                   if (res.cleanedText) {
                     state.accumulatedText += res.cleanedText;
-                    const hasStructuredToolPattern = /<function=[^>]+>/.test(state.accumulatedText) || /\{\s*"(?:name|tool)"\s*:\s*"(?:Task|Read|Write|Edit|Bash|Grep|Glob)"/i.test(state.accumulatedText) || /<tool_call>/.test(state.accumulatedText);
+                    const hasStructuredToolPattern = hasExtractableFunctionTag(state.accumulatedText) || /\{\s*"(?:name|tool)"\s*:\s*"(?:Task|Read|Write|Edit|Bash|Grep|Glob)"/i.test(state.accumulatedText) || /<tool_call>/.test(state.accumulatedText);
                     const shouldHoldBack = hasStructuredToolPattern && state.accumulatedText.length < 1000;
                     if (shouldHoldBack) {
                       log(`[Streaming] Text held back (structured tool pattern): ${state.accumulatedText.length} chars accumulated`);
@@ -35177,6 +35259,57 @@ var init_middleware = __esm(() => {
   init_gemini_thought_signature();
 });
 
+// src/model-params.ts
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMergeParams(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (isPlainObject3(value) && isPlainObject3(target[key])) {
+      deepMergeParams(target[key], value);
+    } else if (isPlainObject3(value)) {
+      target[key] = deepMergeParams({}, value);
+    } else {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+function coerceValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function parseModelParams(spec, into = {}) {
+  for (const item of spec.split(",")) {
+    const trimmed2 = item.trim();
+    if (!trimmed2)
+      continue;
+    const eq = trimmed2.indexOf("=");
+    if (eq <= 0) {
+      throw new Error(`--model-params item "${trimmed2}" must be key=value`);
+    }
+    const key = trimmed2.slice(0, eq).trim();
+    const raw = trimmed2.slice(eq + 1);
+    const path = key.split(".");
+    if (path.some((seg) => seg.length === 0)) {
+      throw new Error(`--model-params key "${key}" has an empty dot segment`);
+    }
+    const nested = {};
+    let cursor = nested;
+    for (const seg of path.slice(0, -1)) {
+      const child = {};
+      cursor[seg] = child;
+      cursor = child;
+    }
+    cursor[path[path.length - 1]] = coerceValue(raw);
+    deepMergeParams(into, nested);
+  }
+  return into;
+}
+
 // src/handlers/shared/quota-exhaustion.ts
 function hasQuotaExhaustionWording(errorBody) {
   const lower = (errorBody || "").toLowerCase();
@@ -39198,6 +39331,362 @@ var init_vision_proxy = __esm(() => {
   init_catalog_query();
 });
 
+// src/session-events/event-translator.ts
+function translateLine(line) {
+  let record4;
+  try {
+    record4 = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (record4 === null || typeof record4 !== "object")
+    return null;
+  const at = typeof record4.timestamp === "string" ? record4.timestamp : undefined;
+  if (record4.type === "attachment") {
+    const attachmentType = record4.attachment?.type;
+    if (attachmentType === "ultra_effort_enter")
+      return { kind: "ultra_effort_enter", at };
+    if (attachmentType === "ultra_effort_exit")
+      return { kind: "ultra_effort_exit", at };
+    return {
+      kind: "unknown",
+      attachmentType: typeof attachmentType === "string" ? attachmentType : undefined,
+      at
+    };
+  }
+  if (record4.type === "user") {
+    const content = record4.message?.content;
+    if (typeof content === "string" && content.includes("<local-command-stdout>")) {
+      const match = content.match(EFFORT_STDOUT_RE);
+      if (match) {
+        const scope = match[2] === "this session only" ? "session" : "default";
+        return { kind: "effort_changed", level: match[1], scope, at };
+      }
+    }
+  }
+  return null;
+}
+var EFFORT_STDOUT_RE;
+var init_event_translator = __esm(() => {
+  EFFORT_STDOUT_RE = /Set effort level to (\S+) \((this session only|saved as your default)/;
+});
+
+// src/session-events/session-state.ts
+function initialState(seed) {
+  if (seed?.defaultEffort) {
+    return {
+      ultracodeActive: false,
+      effort: seed.defaultEffort,
+      defaultEffort: seed.defaultEffort,
+      seededFrom: "settings"
+    };
+  }
+  return { ultracodeActive: false, seededFrom: "none" };
+}
+function reduceEvent(state, event) {
+  const next = { ...state, lastEventAt: event.at ?? state.lastEventAt };
+  switch (event.kind) {
+    case "ultra_effort_enter":
+      next.ultracodeActive = true;
+      return next;
+    case "ultra_effort_exit":
+      next.ultracodeActive = false;
+      return next;
+    case "effort_changed":
+      next.effort = event.level;
+      next.effortScope = event.scope;
+      next.ultracodeActive = event.level === "ultracode";
+      if (event.scope === "default")
+        next.defaultEffort = event.level;
+      return next;
+    default:
+      return next;
+  }
+}
+
+// src/session-events/transcript-tailer.ts
+import { closeSync as closeSync5, openSync as openSync5, readSync, statSync as statSync4 } from "fs";
+
+class TranscriptTailer {
+  filePath;
+  onLine;
+  opts;
+  offset = 0;
+  buffer = "";
+  decoder = new TextDecoder;
+  timer = null;
+  disposed = false;
+  constructor(filePath, onLine, opts = {}) {
+    this.filePath = filePath;
+    this.onLine = onLine;
+    this.opts = opts;
+  }
+  start() {
+    if (this.disposed)
+      return;
+    this.tick();
+    this.schedule();
+  }
+  syncNow() {
+    this.tick();
+  }
+  dispose() {
+    this.disposed = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  schedule() {
+    if (this.disposed)
+      return;
+    this.timer = setTimeout(() => {
+      this.tick();
+      this.schedule();
+    }, this.opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
+    this.timer.unref?.();
+  }
+  tick() {
+    if (this.disposed)
+      return;
+    try {
+      const size = statSync4(this.filePath).size;
+      if (size < this.offset) {
+        this.offset = 0;
+        this.buffer = "";
+        this.decoder = new TextDecoder;
+      }
+      if (size === this.offset)
+        return;
+      const fd = openSync5(this.filePath, "r");
+      let chunk;
+      try {
+        chunk = Buffer.alloc(size - this.offset);
+        const bytesRead = readSync(fd, chunk, 0, chunk.length, this.offset);
+        this.offset += bytesRead;
+        if (bytesRead < chunk.length)
+          chunk = chunk.subarray(0, bytesRead);
+      } finally {
+        closeSync5(fd);
+      }
+      this.buffer += this.decoder.decode(chunk, { stream: true });
+      const lines = this.buffer.split(`
+`);
+      this.buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.trim())
+          this.onLine(line);
+      }
+    } catch (err) {
+      this.dispose();
+      this.opts.onError?.(err);
+    }
+  }
+}
+var DEFAULT_POLL_INTERVAL_MS = 250;
+var init_transcript_tailer = () => {};
+
+// src/session-events/index.ts
+import { existsSync as existsSync16, readFileSync as readFileSync15, readdirSync as readdirSync3 } from "fs";
+import { homedir as homedir23 } from "os";
+import { join as join23 } from "path";
+function extractSessionId2(metadata) {
+  const userId = metadata?.user_id;
+  if (typeof userId !== "string")
+    return;
+  try {
+    const parsed = JSON.parse(userId);
+    if (typeof parsed?.session_id === "string" && parsed.session_id) {
+      return parsed.session_id;
+    }
+  } catch {}
+  const match = userId.match(/session_([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+  return match?.[1];
+}
+function slugFromCwd(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, "-");
+}
+
+class SessionEventRegistry {
+  sessions = new Map;
+  misses = new Map;
+  subscribers = [];
+  claudeHome;
+  pollIntervalMs;
+  constructor(opts = {}) {
+    this.claudeHome = opts.claudeHome ?? join23(homedir23(), ".claude");
+    this.pollIntervalMs = opts.pollIntervalMs;
+  }
+  ensureSession(sessionId) {
+    try {
+      this.sweepIdle();
+      const existing = this.sessions.get(sessionId);
+      if (existing) {
+        existing.lastActivity = Date.now();
+        return;
+      }
+      const miss = this.misses.get(sessionId);
+      if (miss) {
+        if (miss.count >= MAX_MISSES)
+          return;
+        if (Date.now() - miss.lastTry < MISS_TTL_MS)
+          return;
+      }
+      const filePath = this.locateTranscript(sessionId);
+      if (!filePath) {
+        const count = (miss?.count ?? 0) + 1;
+        this.misses.set(sessionId, { lastTry: Date.now(), count });
+        if (count === MAX_MISSES) {
+          log(`[SessionEvents] transcript for session ${sessionId} not found after ${MAX_MISSES} attempts \u2014 giving up`);
+        }
+        return;
+      }
+      this.misses.delete(sessionId);
+      const entry = {
+        state: initialState({ defaultEffort: this.readSettingsEffortLevel() }),
+        tailer: new TranscriptTailer(filePath, (line) => this.onLine(sessionId, line), {
+          pollIntervalMs: this.pollIntervalMs,
+          onError: (err) => log(`[SessionEvents] tailer for ${sessionId} stopped: ${err}`)
+        }),
+        lastActivity: Date.now()
+      };
+      this.sessions.set(sessionId, entry);
+      entry.tailer.start();
+      log(`[SessionEvents] tailing ${filePath}`);
+    } catch (err) {
+      log(`[SessionEvents] ensureSession(${sessionId}) failed: ${err}`);
+    }
+  }
+  sync(sessionId) {
+    try {
+      const entry = this.sessions.get(sessionId);
+      if (entry) {
+        entry.lastActivity = Date.now();
+        entry.tailer.syncNow();
+      }
+    } catch (err) {
+      log(`[SessionEvents] sync(${sessionId}) failed: ${err}`);
+    }
+  }
+  getState(sessionId) {
+    return this.sessions.get(sessionId)?.state;
+  }
+  subscribe(fn) {
+    this.subscribers.push(fn);
+    return () => {
+      this.subscribers = this.subscribers.filter((s) => s !== fn);
+    };
+  }
+  disposeAll() {
+    for (const entry of this.sessions.values()) {
+      entry.tailer.dispose();
+    }
+    this.sessions.clear();
+    this.misses.clear();
+  }
+  onLine(sessionId, line) {
+    const event = translateLine(line);
+    if (!event)
+      return;
+    const entry = this.sessions.get(sessionId);
+    if (!entry)
+      return;
+    entry.state = reduceEvent(entry.state, event);
+    log(`[SessionEvents] ${sessionId}: ${event.kind}${event.kind === "effort_changed" ? ` level=${event.level} scope=${event.scope}` : ""} \u2192 ultracodeActive=${entry.state.ultracodeActive}`);
+    for (const fn of this.subscribers) {
+      try {
+        fn(sessionId, event);
+      } catch {}
+    }
+  }
+  locateTranscript(sessionId) {
+    const projectsDir = join23(this.claudeHome, "projects");
+    const primary = join23(projectsDir, slugFromCwd(process.cwd()), `${sessionId}.jsonl`);
+    if (existsSync16(primary))
+      return primary;
+    try {
+      for (const dir of readdirSync3(projectsDir)) {
+        const candidate = join23(projectsDir, dir, `${sessionId}.jsonl`);
+        if (existsSync16(candidate))
+          return candidate;
+      }
+    } catch {}
+    return;
+  }
+  readSettingsEffortLevel() {
+    try {
+      const settings = JSON.parse(readFileSync15(join23(this.claudeHome, "settings.json"), "utf-8"));
+      return typeof settings.effortLevel === "string" ? settings.effortLevel : undefined;
+    } catch {
+      return;
+    }
+  }
+  sweepIdle() {
+    const now2 = Date.now();
+    for (const [sid, entry] of this.sessions) {
+      if (now2 - entry.lastActivity > IDLE_SWEEP_MS) {
+        entry.tailer.dispose();
+        this.sessions.delete(sid);
+      }
+    }
+  }
+}
+var MISS_TTL_MS = 5000, MAX_MISSES = 5, IDLE_SWEEP_MS, sessionEvents;
+var init_session_events = __esm(() => {
+  init_logger();
+  init_event_translator();
+  init_transcript_tailer();
+  IDLE_SWEEP_MS = 30 * 60 * 1000;
+  sessionEvents = new SessionEventRegistry;
+});
+
+// src/session-events/pro-injection.ts
+function resolveVariantPreset(bareModelName, provider, cachePath) {
+  for (const variant of lookupVariantPresets(bareModelName, provider, cachePath)) {
+    try {
+      const params = parseModelParams(variant.preset);
+      if (Object.keys(params).length === 0)
+        continue;
+      return {
+        params,
+        variantModelId: variant.modelId,
+        provider: variant.provider,
+        preset: variant.preset
+      };
+    } catch {}
+  }
+  return;
+}
+function applyProInjection(requestPayload, opts) {
+  try {
+    if (!opts.enabled || !opts.sessionId)
+      return false;
+    if (opts.outputConfig?.effort !== "xhigh")
+      return false;
+    if (opts.outputConfig?.format)
+      return false;
+    const registry2 = opts.registry ?? sessionEvents;
+    registry2.ensureSession(opts.sessionId);
+    registry2.sync(opts.sessionId);
+    const state = registry2.getState(opts.sessionId);
+    if (!state?.ultracodeActive)
+      return false;
+    const resolved = resolveVariantPreset(opts.bareModelName, opts.provider, opts.cachePath);
+    if (!resolved)
+      return false;
+    deepMergeParams(requestPayload, resolved.params);
+    log(`[SessionEvents] ultracode active \u2192 preset ${resolved.preset} for ${opts.targetModel} ` + `(catalog variant ${resolved.variantModelId} @ ${resolved.provider}, session ${opts.sessionId})`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_pro_injection = __esm(() => {
+  init_model_catalog();
+  init_logger();
+  init_session_events();
+});
+
 // src/providers/model-parser.ts
 function parseModelChain(modelSpec) {
   const parts = modelSpec.split(MODEL_CHAIN_SEPARATOR).map((s) => s.trim()).filter(Boolean);
@@ -39313,25 +39802,25 @@ var init_model_parser = __esm(() => {
 
 // src/stats-buffer.ts
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   renameSync as renameSync2,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync8
 } from "fs";
-import { homedir as homedir23 } from "os";
-import { join as join23 } from "path";
+import { homedir as homedir24 } from "os";
+import { join as join24 } from "path";
 function ensureDir() {
-  if (!existsSync16(CLAUDISH_DIR)) {
+  if (!existsSync17(CLAUDISH_DIR)) {
     mkdirSync9(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
   try {
-    if (!existsSync16(BUFFER_FILE))
+    if (!existsSync17(BUFFER_FILE))
       return [];
-    const raw = readFileSync15(BUFFER_FILE, "utf-8");
+    const raw = readFileSync16(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.events))
       return [];
@@ -39356,7 +39845,7 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed2 = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed2 };
-    const tmpFile = join23(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    const tmpFile = join24(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
     writeFileSync8(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync2(tmpFile, BUFFER_FILE);
     memoryCache = trimmed2;
@@ -39400,7 +39889,7 @@ function clearBuffer() {
   try {
     memoryCache = [];
     eventsSinceLastFlush = 0;
-    if (existsSync16(BUFFER_FILE)) {
+    if (existsSync17(BUFFER_FILE)) {
       unlinkSync5(BUFFER_FILE);
     }
   } catch {}
@@ -39429,8 +39918,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, flushScheduled = false, SIGNAL_EXIT_CODE;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join23(homedir23(), ".claudish");
-  BUFFER_FILE = join23(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join24(homedir24(), ".claudish");
+  BUFFER_FILE = join24(CLAUDISH_DIR, "stats-buffer.json");
   process.on("exit", syncFlushOnExit);
   SIGNAL_EXIT_CODE = { SIGTERM: 143, SIGINT: 130 };
   for (const signal of ["SIGTERM", "SIGINT"]) {
@@ -42548,8 +43037,8 @@ var init_openai_responses_sse = __esm(() => {
 
 // src/handlers/shared/token-tracker.ts
 import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir24 } from "os";
-import { dirname as dirname8, join as join24 } from "path";
+import { homedir as homedir25 } from "os";
+import { dirname as dirname8, join as join25 } from "path";
 function stripProviderPrefix(name) {
   const at = name.indexOf("@");
   return at === -1 ? name : name.slice(at + 1);
@@ -42573,7 +43062,8 @@ class TokenTracker {
     this.config = config2;
   }
   recordToolUse(name) {
-    const key = name.trim() || "unknown";
+    const trimmed2 = name.trim();
+    const key = !trimmed2 ? "unknown" : TOOL_NAME_SHAPE.test(trimmed2) ? trimmed2 : "malformed";
     this.toolCallsByName.set(key, (this.toolCallsByName.get(key) ?? 0) + 1);
   }
   getToolCallCount() {
@@ -42737,7 +43227,7 @@ class TokenTracker {
         };
       }
       const override = process.env.CLAUDISH_TOKEN_FILE;
-      const outPath = override || join24(homedir24(), ".claudish", `tokens-${this.port}.json`);
+      const outPath = override || join25(homedir25(), ".claudish", `tokens-${this.port}.json`);
       mkdirSync10(dirname8(outPath), { recursive: true });
       writeFileSync9(outPath, JSON.stringify(data), "utf-8");
     } catch (e) {
@@ -42746,6 +43236,7 @@ class TokenTracker {
   }
 }
 var init_token_tracker = __esm(() => {
+  init_tool_name_utils();
   init_types2();
   init_logger();
   init_remote_provider_types();
@@ -42862,6 +43353,12 @@ class ComposedHandler {
     }
     this.middlewareManager.initialize().catch((err) => log(`[ComposedHandler:${this.bareModelName}] Middleware init error: ${err}`));
     this.behaviorEngine = getBehaviorEngine();
+    if (options.effortOverride) {
+      for (const dialect of new Set([this.explicitAdapter, this.resolvedDialect, this.modelAdapter].filter(Boolean))) {
+        dialect.setEffortOverride(options.effortOverride);
+      }
+      log(`[ComposedHandler] --effort ${options.effortOverride} pinned for ${this.targetModel} (catalog clamp skipped)`);
+    }
     this.tokenTracker = new TokenTracker(port, {
       contextWindow: this.getModelContextWindow(),
       providerName: provider.name,
@@ -43000,6 +43497,22 @@ class ComposedHandler {
       this.modelAdapter.prepareRequest(requestPayload, claudeRequest);
     }
     const toolNameMap = adapter.getToolNameMap();
+    if (this.options.proOnUltracode) {
+      applyProInjection(requestPayload, {
+        enabled: true,
+        sessionId: extractSessionId2(claudeRequest?.metadata),
+        bareModelName: this.bareModelName,
+        provider: this.provider.name,
+        targetModel: this.targetModel,
+        outputConfig: claudeRequest?.output_config,
+        registry: this.options.sessionEventRegistry,
+        cachePath: this.options.catalogCachePath
+      });
+    }
+    if (this.options.modelParams) {
+      deepMergeParams(requestPayload, this.options.modelParams);
+      log(`[ComposedHandler] Merged --model-params (${Object.keys(this.options.modelParams).join(", ")}) for ${this.targetModel}`);
+    }
     if (this.provider.refreshAuth) {
       try {
         await this.provider.refreshAuth();
@@ -43716,6 +44229,8 @@ var init_composed_handler = __esm(() => {
   init_middleware();
   init_openai();
   init_vision_proxy();
+  init_session_events();
+  init_pro_injection();
   init_stats();
   init_telemetry();
   init_transform();
@@ -43739,11 +44254,11 @@ var init_composed_handler = __esm(() => {
 });
 
 // src/providers/api-key-provenance.ts
-import { existsSync as existsSync17, readFileSync as readFileSync16 } from "fs";
-import { homedir as homedir25 } from "os";
-import { join as join25, resolve as resolve2 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync17 } from "fs";
+import { homedir as homedir26 } from "os";
+import { join as join26, resolve as resolve2 } from "path";
 function activeConfigPath() {
-  return activeGlobalConfigFile(join25(homedir25(), ".claudish", "config.json"));
+  return activeGlobalConfigFile(join26(homedir26(), ".claudish", "config.json"));
 }
 function configLayerLabel() {
   return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
@@ -43823,9 +44338,9 @@ function formatProvenanceLog(p) {
 function readDotenvKey(envVars) {
   try {
     const dotenvPath = resolve2(".env");
-    if (!existsSync17(dotenvPath))
+    if (!existsSync18(dotenvPath))
       return null;
-    const parsed = import_dotenv.parse(readFileSync16(dotenvPath, "utf-8"));
+    const parsed = import_dotenv.parse(readFileSync17(dotenvPath, "utf-8"));
     for (const v of envVars) {
       if (parsed[v])
         return parsed[v];
@@ -43838,9 +44353,9 @@ function readDotenvKey(envVars) {
 function readConfigKey(envVar) {
   try {
     const configPath = activeConfigPath();
-    if (!existsSync17(configPath))
+    if (!existsSync18(configPath))
       return null;
-    const cfg = JSON.parse(readFileSync16(configPath, "utf-8"));
+    const cfg = JSON.parse(readFileSync17(configPath, "utf-8"));
     return cfg.apiKeys?.[envVar] || null;
   } catch {
     return null;
@@ -48354,9 +48869,9 @@ __export(exports_session_discovery, {
   transcriptPathFor: () => transcriptPathFor
 });
 import { execFile, execFileSync as execFileSync2 } from "child_process";
-import { closeSync as closeSync5, openSync as openSync5, readSync, readdirSync as readdirSync3, realpathSync, statSync as statSync4 } from "fs";
-import { homedir as homedir26 } from "os";
-import { basename, join as join26 } from "path";
+import { closeSync as closeSync6, openSync as openSync6, readSync as readSync2, readdirSync as readdirSync4, realpathSync, statSync as statSync5 } from "fs";
+import { homedir as homedir27 } from "os";
+import { basename, join as join27 } from "path";
 function slugForPath(absPath) {
   return absPath.replace(/[/.]/g, "-");
 }
@@ -48365,7 +48880,7 @@ function transcriptPathFor(cwd, sessionUuid) {
   try {
     real = realpathSync(cwd);
   } catch {}
-  return join26(PROJECTS_DIR, slugForPath(real), `${sessionUuid}.jsonl`);
+  return join27(PROJECTS_DIR, slugForPath(real), `${sessionUuid}.jsonl`);
 }
 function isAgentSession(row) {
   return row.entrypoint !== undefined && row.entrypoint !== "cli";
@@ -48406,24 +48921,24 @@ function getRepoContext(cwd = process.cwd()) {
 }
 function projectDirs() {
   try {
-    return readdirSync3(PROJECTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    return readdirSync4(PROJECTS_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch {
     return [];
   }
 }
 function sessionsIn(dirName) {
-  const dir = join26(PROJECTS_DIR, dirName);
+  const dir = join27(PROJECTS_DIR, dirName);
   let names;
   try {
-    names = readdirSync3(dir).filter((n) => n.endsWith(".jsonl"));
+    names = readdirSync4(dir).filter((n) => n.endsWith(".jsonl"));
   } catch {
     return [];
   }
   const rows = [];
   for (const n of names) {
-    const file2 = join26(dir, n);
+    const file2 = join27(dir, n);
     try {
-      const st = statSync4(file2);
+      const st = statSync5(file2);
       if (st.size === 0)
         continue;
       const row = {
@@ -48583,7 +49098,7 @@ function discoverWorktreeGroups(repo) {
     g.activeNow = g.sessions.some((s) => isActive(s));
     if (g.path) {
       try {
-        g.createdMs = statSync4(g.path).birthtimeMs;
+        g.createdMs = statSync5(g.path).birthtimeMs;
       } catch {}
     }
     if (!g.createdMs && g.sessions.length > 0) {
@@ -48601,16 +49116,16 @@ function readChunk(file2, pos, len) {
     return "";
   let fd = null;
   try {
-    fd = openSync5(file2, "r");
+    fd = openSync6(file2, "r");
     const buf = Buffer.allocUnsafe(len);
-    const n = readSync(fd, buf, 0, len, pos);
+    const n = readSync2(fd, buf, 0, len, pos);
     return buf.subarray(0, n).toString("utf-8");
   } catch {
     return "";
   } finally {
     if (fd !== null) {
       try {
-        closeSync5(fd);
+        closeSync6(fd);
       } catch {}
     }
   }
@@ -48671,7 +49186,7 @@ function hydrateSession(row) {
   row.hydrated = true;
   if (isActive(row)) {
     try {
-      row.sizeBytes = statSync4(row.file).size;
+      row.sizeBytes = statSync5(row.file).size;
     } catch {}
   }
   const head = parseRecords(readChunk(row.file, 0, Math.min(HEAD_BYTES, row.sizeBytes)), false);
@@ -48780,7 +49295,7 @@ function findLatestSessionId(cwd = process.cwd(), sinceMs = 0) {
 }
 var ENTRYPOINT_BYTES = 8192, PROJECTS_DIR, ACTIVE_WINDOW_MS = 120000, HEAD_BYTES, TAIL_BYTES, HARNESS_ENVELOPES, DEEP_TAIL_BYTES, RECENT_AI_TURNS = 5, RECENT_USER_TURNS = 1;
 var init_session_discovery = __esm(() => {
-  PROJECTS_DIR = join26(homedir26(), ".claude", "projects");
+  PROJECTS_DIR = join27(homedir27(), ".claude", "projects");
   HEAD_BYTES = 64 * 1024;
   TAIL_BYTES = 128 * 1024;
   HARNESS_ENVELOPES = [
@@ -48805,19 +49320,19 @@ function resolveClaudishSpawn(env = process.env) {
 var CLAUDISH_BIN_ENV = "CLAUDISH_BIN";
 
 // src/team-stats.ts
-import { existsSync as existsSync18, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "fs";
+import { join as join28 } from "path";
 function statsDir(sessionPath) {
-  return join27(sessionPath, "stats");
+  return join28(sessionPath, "stats");
 }
 function tokenFileFor(sessionPath, anonId) {
-  return join27(statsDir(sessionPath), `${anonId}.json`);
+  return join28(statsDir(sessionPath), `${anonId}.json`);
 }
 function readTokenStatsAt(path) {
-  if (!existsSync18(path))
+  if (!existsSync19(path))
     return null;
   try {
-    return JSON.parse(readFileSync17(path, "utf-8"));
+    return JSON.parse(readFileSync18(path, "utf-8"));
   } catch {
     return null;
   }
@@ -48968,7 +49483,7 @@ ${segs.join(" \xB7 ")}`;
 }
 function writeStatusFile(sessionPath, manifest, status, opts) {
   try {
-    writeFileSync10(join27(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+    writeFileSync10(join28(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
 `, "utf-8");
   } catch {}
 }
@@ -49000,13 +49515,13 @@ __export(exports_team_orchestrator, {
 import { spawn as spawn2 } from "child_process";
 import {
   createWriteStream,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync11,
-  readFileSync as readFileSync18,
-  readdirSync as readdirSync4,
+  readFileSync as readFileSync19,
+  readdirSync as readdirSync5,
   writeFileSync as writeFileSync11
 } from "fs";
-import { join as join28, resolve as resolve3 } from "path";
+import { join as join29, resolve as resolve3 } from "path";
 function resolveCaptureMode(explicit, env = process.env) {
   if (explicit)
     return explicit;
@@ -49095,14 +49610,14 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync19(join28(sessionPath, "manifest.json"))) {
+  if (existsSync20(join29(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. Use a new directory path or delete the existing session first.`);
   }
-  mkdirSync11(join28(sessionPath, "work"), { recursive: true });
-  mkdirSync11(join28(sessionPath, "errors"), { recursive: true });
+  mkdirSync11(join29(sessionPath, "work"), { recursive: true });
+  mkdirSync11(join29(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync11(join28(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync19(join28(sessionPath, "input.md"))) {
+    writeFileSync11(join29(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync20(join29(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"));
@@ -49119,9 +49634,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now2
     };
-    mkdirSync11(join28(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync11(join29(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync11(join28(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync11(join29(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now2,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -49135,7 +49650,7 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync11(join28(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync11(join29(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 function assertValidRequirePattern(pattern) {
@@ -49152,7 +49667,7 @@ function readFullOutputIfNeeded(opts) {
   if (crashed || !requirePattern || outputSize <= STDOUT_TAIL_LIMIT)
     return;
   try {
-    return readFileSync18(outputPath, "utf-8");
+    return readFileSync19(outputPath, "utf-8");
   } catch {
     return;
   }
@@ -49160,12 +49675,12 @@ function readFullOutputIfNeeded(opts) {
 async function runModels(sessionPath, opts = {}) {
   const timeoutMs = (opts.timeout ?? 300) * 1000;
   assertValidRequirePattern(opts.requirePattern);
-  const manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join28(sessionPath, "status.json");
-  const inputPath = join28(sessionPath, "input.md");
-  const inputContent = readFileSync18(inputPath, "utf-8");
+  const manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join29(sessionPath, "status.json");
+  const inputPath = join29(sessionPath, "input.md");
+  const inputContent = readFileSync19(inputPath, "utf-8");
   const spawnPlan = await (opts.spawnPlanner ?? prehydrateCredentialsForSpawn)(Object.values(manifest.models).map((m) => m.model));
-  const statusCache = JSON.parse(readFileSync18(statusPath, "utf-8"));
+  const statusCache = JSON.parse(readFileSync19(statusPath, "utf-8"));
   function updateModelStatus(id, update) {
     statusCache.models[id] = { ...statusCache.models[id], ...update };
     writeFileSync11(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
@@ -49213,8 +49728,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join28(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join28(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join29(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join29(sessionPath, "errors", `${anonId}.log`);
     const spawnModel = spawnPlan.pinned.get(entry.model) ?? entry.model;
     const args = [
       "--model",
@@ -49440,7 +49955,7 @@ async function runModels(sessionPath, opts = {}) {
     opts.onStatusChange?.(id, statusCache.models[id]);
     const stopped = await terminateChildTree(proc);
     if (!stopped) {
-      persistErrorLog(rt?.errorLogPath ?? join28(sessionPath, "errors", `${id}.log`), "TIMEOUT: child survived SIGKILL \u2014 it may still be running and billing", stderr, stdoutTail);
+      persistErrorLog(rt?.errorLogPath ?? join29(sessionPath, "errors", `${id}.log`), "TIMEOUT: child survived SIGKILL \u2014 it may still be running and billing", stderr, stdoutTail);
     }
   };
   const allDone = Promise.all(completionPromises);
@@ -49492,30 +50007,30 @@ async function runModels(sessionPath, opts = {}) {
   return statusCache;
 }
 async function judgeResponses(sessionPath, opts = {}) {
-  const responseFiles = readdirSync4(sessionPath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
+  const responseFiles = readdirSync5(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] = readFileSync18(join28(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync19(join29(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync18(join28(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync19(join29(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync11(join28(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync11(join29(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join28(sessionPath, "judging");
+  const judgePath = join29(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));
-  writeFileSync11(join28(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync11(join29(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync18(join28(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync19(join29(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -49525,7 +50040,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -49583,12 +50098,12 @@ function buildJudgePrompt(input, responses) {
 }
 function parseJudgeVotes(judgePath, responseIds) {
   const votes = [];
-  const responseFiles = readdirSync4(judgePath).filter((f) => f.startsWith("response-") && f.endsWith(".md")).sort();
+  const responseFiles = readdirSync5(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 = readFileSync18(join28(judgePath, file2), "utf-8");
+      content = readFileSync19(join29(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -49640,7 +50155,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync18(join28(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync19(join29(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -49691,17 +50206,17 @@ import { spawn as spawn3 } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 import {
   appendFileSync as appendFileSync6,
-  closeSync as closeSync6,
+  closeSync as closeSync7,
   createWriteStream as createWriteStream2,
   mkdirSync as mkdirSync12,
-  openSync as openSync6,
-  readFileSync as readFileSync19,
-  readSync as readSync2,
-  statSync as statSync5,
+  openSync as openSync7,
+  readFileSync as readFileSync20,
+  readSync as readSync3,
+  statSync as statSync6,
   writeFileSync as writeFileSync12
 } from "fs";
-import { homedir as homedir27 } from "os";
-import { join as join29, resolve as resolve4, sep } from "path";
+import { homedir as homedir28 } from "os";
+import { join as join30, resolve as resolve4, sep } from "path";
 import { StringDecoder } from "string_decoder";
 function buildChannelSpawnArgs(opts) {
   return [
@@ -49739,21 +50254,21 @@ function decodeChunk(decoder, chunk) {
 function readTailText(path, maxBytes) {
   let fd = null;
   try {
-    const size = statSync5(path).size;
+    const size = statSync6(path).size;
     if (size === 0)
       return { text: "", truncated: false };
     const start = Math.max(0, size - maxBytes);
     const length = size - start;
     const buf = Buffer.alloc(length);
-    fd = openSync6(path, "r");
-    readSync2(fd, buf, 0, length, start);
+    fd = openSync7(path, "r");
+    readSync3(fd, buf, 0, length, start);
     return { text: buf.toString("utf-8"), truncated: start > 0 };
   } catch {
     return null;
   } finally {
     if (fd !== null) {
       try {
-        closeSync6(fd);
+        closeSync7(fd);
       } catch {}
     }
   }
@@ -49770,7 +50285,7 @@ function readTailLines(path, maxBytes) {
 }
 function fileSize(path) {
   try {
-    return statSync5(path).size;
+    return statSync6(path).size;
   } catch {
     return 0;
   }
@@ -49779,7 +50294,7 @@ function readJsonObject(path, maxBytes) {
   try {
     if (fileSize(path) > maxBytes)
       return null;
-    const parsed = JSON.parse(readFileSync19(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync20(path, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return null;
     return parsed;
@@ -49795,7 +50310,7 @@ function dropLeadingFragment(tail) {
   return firstBreak === -1 ? tail.text : tail.text.slice(firstBreak + 1);
 }
 function diskAccounting(sessionDir) {
-  const stats = readTokenStatsAt(join29(sessionDir, "tokens.json"));
+  const stats = readTokenStatsAt(join30(sessionDir, "tokens.json"));
   return {
     tokensUsed: (stats?.total_tokens ?? 0) || (stats?.input_tokens ?? 0) + (stats?.output_tokens ?? 0),
     costUsd: stats?.total_cost ?? 0,
@@ -49835,7 +50350,7 @@ class SessionManager {
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.scrollbackCapacity = options?.scrollbackCapacity ?? DEFAULT_SCROLLBACK;
     this.terminalRetentionMs = options?.terminalRetentionMs ?? TERMINAL_RETENTION_MS;
-    this.sessionsDir = options?.sessionsDir ?? process.env.CLAUDISH_SESSIONS_DIR ?? join29(homedir27(), ".claudish", "sessions");
+    this.sessionsDir = options?.sessionsDir ?? process.env.CLAUDISH_SESSIONS_DIR ?? join30(homedir28(), ".claudish", "sessions");
     this.stallSeconds = options?.stallSeconds;
     this.onStateChange = options?.onStateChange;
   }
@@ -49848,19 +50363,19 @@ class SessionManager {
     const claudeSessionId = randomUUID4();
     const timeout = Math.min(opts.timeoutSeconds ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     const startedAt = new Date().toISOString();
-    const sessionDir = join29(this.sessionsDir, sessionId2);
+    const sessionDir = join30(this.sessionsDir, sessionId2);
     mkdirSync12(sessionDir, { recursive: true });
     if (opts.prompt) {
-      writeFileSync12(join29(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync12(join30(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     }
     const args = buildChannelSpawnArgs({
       model: opts.spawnModel ?? opts.model,
       claudeSessionId,
       claudishFlags: opts.claudishFlags
     });
-    const tokenFile = join29(sessionDir, "tokens.json");
-    const eventLogPath = join29(sessionDir, "events.jsonl");
-    const upstreamErrorLogPath = join29(sessionDir, "upstream-errors.jsonl");
+    const tokenFile = join30(sessionDir, "tokens.json");
+    const eventLogPath = join30(sessionDir, "events.jsonl");
+    const upstreamErrorLogPath = join30(sessionDir, "upstream-errors.jsonl");
     const cwd = opts.cwd ?? process.cwd();
     const spawnTarget = resolveClaudishSpawn();
     const proc = spawn3(spawnTarget.command, [...spawnTarget.prefixArgs, ...args], {
@@ -49875,7 +50390,7 @@ class SessionManager {
       }
     });
     const scrollback = new ScrollbackBuffer(this.scrollbackCapacity);
-    const outputLogStream = createWriteStream2(join29(sessionDir, "output.log"));
+    const outputLogStream = createWriteStream2(join30(sessionDir, "output.log"));
     const entry = {
       info: {
         sessionId: sessionId2,
@@ -50159,7 +50674,7 @@ class SessionManager {
       return null;
     const root = resolve4(this.sessionsDir);
     const dir = resolve4(root, sessionId2);
-    if (dir !== join29(root, sessionId2))
+    if (dir !== join30(root, sessionId2))
       return null;
     if (!dir.startsWith(root + sep))
       return null;
@@ -50171,14 +50686,14 @@ class SessionManager {
       return null;
     let dirMtimeMs;
     try {
-      const stat2 = statSync5(sessionDir);
+      const stat2 = statSync6(sessionDir);
       if (!stat2.isDirectory())
         return null;
       dirMtimeMs = stat2.mtimeMs;
     } catch {
       return null;
     }
-    const meta3 = readJsonObject(join29(sessionDir, "meta.json"), META_READ_LIMIT);
+    const meta3 = readJsonObject(join30(sessionDir, "meta.json"), META_READ_LIMIT);
     const partial2 = meta3 === null;
     const measured = diskAccounting(sessionDir);
     const startedAt = metaString(meta3?.startedAt) ?? new Date(dirMtimeMs).toISOString();
@@ -50207,7 +50722,7 @@ class SessionManager {
     };
   }
   diskOutput(record4, tailLines) {
-    const tail = readTailText(join29(record4.sessionDir, "output.log"), OUTPUT_TAIL_BYTES);
+    const tail = readTailText(join30(record4.sessionDir, "output.log"), OUTPUT_TAIL_BYTES);
     const buffer = new ScrollbackBuffer(this.scrollbackCapacity);
     if (tail?.text)
       buffer.append(dropLeadingFragment(tail));
@@ -50225,9 +50740,9 @@ class SessionManager {
   }
   diskDiagnostics(record4, limit) {
     const { sessionDir, info } = record4;
-    const eventLogPath = join29(sessionDir, "events.jsonl");
-    const upstreamErrorLogPath = join29(sessionDir, "upstream-errors.jsonl");
-    const outputLogPath = join29(sessionDir, "output.log");
+    const eventLogPath = join30(sessionDir, "events.jsonl");
+    const upstreamErrorLogPath = join30(sessionDir, "upstream-errors.jsonl");
+    const outputLogPath = join30(sessionDir, "output.log");
     const events = readTailLines(eventLogPath, EVENT_TAIL_BYTES);
     const outputTail = readTailText(outputLogPath, OUTPUT_TAIL_BYTES);
     return {
@@ -50268,7 +50783,7 @@ class SessionManager {
     };
   }
   diskStderrForDiagnostics(record4) {
-    const tail = readTailText(join29(record4.sessionDir, "stderr.log"), STDERR_READ_BYTES);
+    const tail = readTailText(join30(record4.sessionDir, "stderr.log"), STDERR_READ_BYTES);
     const raw = tail?.text ?? "";
     const filtered = record4.info.status === "completed";
     const source = filtered ? meaningfulStderr(raw) : raw;
@@ -50443,11 +50958,11 @@ ${STDERR_TRUNCATION_MARKER} ${STDERR_SIDE_LIMIT} bytes per end \u2026
     entry.outputLogStream?.end();
     entry.outputLogStream = null;
     if (entry.stderr) {
-      writeFileSync12(join29(entry.sessionDir, "stderr.log"), redactSecrets(entry.stderr), "utf-8");
+      writeFileSync12(join30(entry.sessionDir, "stderr.log"), redactSecrets(entry.stderr), "utf-8");
     }
     this.refreshAccounting(entry);
     entry.info.claudeSessionId = entry.reducer.claudeSessionId ?? entry.info.claudeSessionId;
-    writeFileSync12(join29(entry.sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
+    writeFileSync12(join30(entry.sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
   }
   scheduleEviction(entry) {
     if (entry.evictHandle)
@@ -50507,7 +51022,7 @@ ${STDERR_TRUNCATION_MARKER} ${STDERR_SIDE_LIMIT} bytes per end \u2026
     return { state: "completed", content: "" };
   }
   refreshAccounting(entry) {
-    const stats = readTokenStatsAt(join29(entry.sessionDir, "tokens.json"));
+    const stats = readTokenStatsAt(join30(entry.sessionDir, "tokens.json"));
     const fileTokens = (stats?.total_tokens ?? 0) || (stats?.input_tokens ?? 0) + (stats?.output_tokens ?? 0);
     entry.info.tokensUsed = fileTokens || entry.reducer.tokens;
     entry.info.costUsd = stats?.total_cost ?? 0;
@@ -50766,9 +51281,9 @@ function compareByReleaseDateDesc(a, b) {
 }
 
 // src/model-loader.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync20, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir28 } from "os";
-import { join as join30 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir29 } from "os";
+import { join as join31 } from "path";
 function groupRecommendedModels(entries) {
   const byId = new Map;
   const categoryOrder = new Map;
@@ -50887,9 +51402,9 @@ async function getRecommendedModels(opts = {}) {
   if (!forceRefresh && _cachedRecommendedModels) {
     return _cachedRecommendedModels;
   }
-  if (!forceRefresh && existsSync20(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (!forceRefresh && existsSync21(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync20(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync21(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -50905,7 +51420,7 @@ async function getRecommendedModels(opts = {}) {
       if (data.models && data.models.length > 0) {
         _cachedRecommendedModels = data;
         try {
-          const cacheDir = join30(homedir28(), ".claudish");
+          const cacheDir = join31(homedir29(), ".claudish");
           mkdirSync13(cacheDir, { recursive: true });
           writeFileSync13(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
         } catch {}
@@ -50918,9 +51433,9 @@ async function getRecommendedModels(opts = {}) {
 function getRecommendedModelsSync() {
   if (_cachedRecommendedModels)
     return _cachedRecommendedModels;
-  if (existsSync20(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (existsSync21(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
-      const cacheData = JSON.parse(readFileSync20(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
+      const cacheData = JSON.parse(readFileSync21(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
         _cachedRecommendedModels = cacheData;
         return cacheData;
@@ -51044,7 +51559,7 @@ var _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels =
 var init_model_loader = __esm(() => {
   init_cache_ttl();
   FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommended`;
-  RECOMMENDED_MODELS_CACHE_PATH = join30(homedir28(), ".claudish", "recommended-models-cache.json");
+  RECOMMENDED_MODELS_CACHE_PATH = join31(homedir29(), ".claudish", "recommended-models-cache.json");
   FIREBASE_SLUG_TO_PROVIDER_NAME = {
     openai: "openai",
     google: "google",
@@ -54945,9 +55460,9 @@ var init_poe = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { existsSync as existsSync21, readFileSync as readFileSync21, statSync as statSync6 } from "fs";
-import { homedir as homedir29 } from "os";
-import { join as join31 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync22, statSync as statSync7 } from "fs";
+import { homedir as homedir30 } from "os";
+import { join as join32 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -54985,12 +55500,12 @@ async function warmPricingCache() {
 }
 function loadDiskCache() {
   try {
-    if (!existsSync21(CACHE_FILE))
+    if (!existsSync22(CACHE_FILE))
       return false;
-    const stat2 = statSync6(CACHE_FILE);
+    const stat2 = statSync7(CACHE_FILE);
     const age = Date.now() - stat2.mtimeMs;
     const isFresh = age < CACHE_TTL_MS3;
-    const raw2 = readFileSync21(CACHE_FILE, "utf-8");
+    const raw2 = readFileSync22(CACHE_FILE, "utf-8");
     const data = JSON.parse(raw2);
     for (const [key, pricing] of Object.entries(data)) {
       pricingMap.set(key, pricing);
@@ -55006,8 +55521,8 @@ var init_pricing_cache = __esm(() => {
   init_logger();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join31(homedir29(), ".claudish");
-  CACHE_FILE = join31(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join32(homedir30(), ".claudish");
+  CACHE_FILE = join32(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 });
 
@@ -55017,12 +55532,12 @@ __export(exports_proxy_server, {
   createProxyServer: () => createProxyServer
 });
 import { appendFileSync as appendFileSync8, mkdirSync as mkdirSync14 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function maybeCaptureClassifierRequest(c, body) {
   if (!process.env.CLAUDISH_CLASSIFIER_DEBUG)
     return;
   try {
-    const dir = join32(process.cwd(), "logs");
+    const dir = join33(process.cwd(), "logs");
     if (!classifierCaptureDirReady) {
       mkdirSync14(dir, { recursive: true });
       classifierCaptureDirReady = true;
@@ -55047,7 +55562,7 @@ function maybeCaptureClassifierRequest(c, body) {
         "x-api-key": c.req.header("x-api-key") ? "<present>" : null
       }
     };
-    appendFileSync8(join32(dir, "classifier-capture.jsonl"), `${JSON.stringify(record4)}
+    appendFileSync8(join33(dir, "classifier-capture.jsonl"), `${JSON.stringify(record4)}
 `);
   } catch {}
 }
@@ -55070,6 +55585,11 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
     log(`[Proxy] behavior hooks load skipped: ${err instanceof Error ? err.message : String(err)}`);
   }
   const nativeHandler = new NativeHandler(anthropicApiKey, options.advisorModels, options.advisorCollector);
+  const requestShapingOpts = {
+    effortOverride: isEffortLevel(options.effortOverride) ? options.effortOverride : undefined,
+    modelParams: options.modelParams,
+    proOnUltracode: options.proOnUltracode
+  };
   const openRouterHandlers = new Map;
   const localProviderHandlers = new Map;
   const remoteProviderHandlers = new Map;
@@ -55083,7 +55603,8 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
       openRouterHandlers.set(modelId, new ComposedHandler(orProvider, modelId, modelId, port, {
         adapter: orAdapter,
         isInteractive: options.isInteractive,
-        invocationMode
+        invocationMode,
+        ...requestShapingOpts
       }));
     }
     return openRouterHandlers.get(modelId);
@@ -55098,7 +55619,8 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
       const poeTransport = new PoeProvider;
       poeHandlers.set(modelId, new ComposedHandler(poeTransport, modelId, modelId, port, {
         isInteractive: options.isInteractive,
-        invocationMode
+        invocationMode,
+        ...requestShapingOpts
       }));
     }
     return poeHandlers.get(modelId);
@@ -55121,7 +55643,8 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
         tokenStrategy: "local",
         summarizeTools: options.summarizeTools,
         isInteractive: options.isInteractive,
-        invocationMode
+        invocationMode,
+        ...requestShapingOpts
       });
       localProviderHandlers.set(targetModel, handler);
       log(`[Proxy] Created local provider handler: ${resolved.provider.name}/${resolved.modelName}${resolved.concurrency !== undefined ? ` (concurrency: ${resolved.concurrency})` : ""}`);
@@ -55137,7 +55660,8 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
         tokenStrategy: "local",
         summarizeTools: options.summarizeTools,
         isInteractive: options.isInteractive,
-        invocationMode
+        invocationMode,
+        ...requestShapingOpts
       });
       localProviderHandlers.set(targetModel, handler);
       log(`[Proxy] Created URL-based local provider handler: ${urlParsed.baseUrl}/${urlParsed.modelName}`);
@@ -55192,7 +55716,7 @@ async function createProxyServer(port, _openrouterApiKey, model, monitorMode = f
         apiKey,
         targetModel,
         port,
-        sharedOpts: { isInteractive: options.isInteractive, invocationMode }
+        sharedOpts: { isInteractive: options.isInteractive, invocationMode, ...requestShapingOpts }
       });
       if (!handler) {
         return null;
@@ -55515,6 +56039,7 @@ var RoutingError, classifierCaptureDirReady = false;
 var init_proxy_server = __esm(() => {
   init_dist();
   init_cors();
+  init_base_api_format();
   init_local_adapter();
   init_openrouter_api_format();
   init_authority();
@@ -55560,14 +56085,14 @@ __export(exports_mcp_server, {
   runPromptViaProxy: () => runPromptViaProxy,
   startMcpServer: () => startMcpServer
 });
-import { existsSync as existsSync22, mkdirSync as mkdirSync15, readFileSync as readFileSync22, readdirSync as readdirSync5, writeFileSync as writeFileSync14 } from "fs";
-import { homedir as homedir30 } from "os";
-import { dirname as dirname9, join as join33, resolve as resolve5 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync23, readdirSync as readdirSync6, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir31 } from "os";
+import { dirname as dirname9, join as join34, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
-  if (!forceRefresh && existsSync22(ALL_MODELS_CACHE_PATH2)) {
+  if (!forceRefresh && existsSync23(ALL_MODELS_CACHE_PATH2)) {
     try {
-      const cacheData = JSON.parse(readFileSync22(ALL_MODELS_CACHE_PATH2, "utf-8"));
+      const cacheData = JSON.parse(readFileSync23(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) {
@@ -55585,8 +56110,8 @@ async function loadAllModels(forceRefresh = false) {
     writeFileSync14(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
-    if (existsSync22(ALL_MODELS_CACHE_PATH2)) {
-      const cacheData = JSON.parse(readFileSync22(ALL_MODELS_CACHE_PATH2, "utf-8"));
+    if (existsSync23(ALL_MODELS_CACHE_PATH2)) {
+      const cacheData = JSON.parse(readFileSync23(ALL_MODELS_CACHE_PATH2, "utf-8"));
       return cacheData.models || [];
     }
     return [];
@@ -56324,7 +56849,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       let stderrFull = stderr_snippet || "";
       if (error_log_path) {
         try {
-          stderrFull = readFileSync22(error_log_path, "utf-8");
+          stderrFull = readFileSync23(error_log_path, "utf-8");
         } catch {}
       }
       const sessionData = {};
@@ -56332,26 +56857,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] = readFileSync22(join33(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync23(join34(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join33(sp, "errors");
-          if (existsSync22(errorDir)) {
-            for (const f of readdirSync5(errorDir)) {
+          const errorDir = join34(sp, "errors");
+          if (existsSync23(errorDir)) {
+            for (const f of readdirSync6(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync22(join33(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync23(join34(errorDir, f), "utf-8");
                 } catch {}
               }
             }
           }
         } catch {}
         try {
-          for (const f of readdirSync5(sp)) {
+          for (const f of readdirSync6(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync22(join33(sp, f), "utf-8");
+                const content = readFileSync23(join34(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -56360,9 +56885,9 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join33(__dirname2, "../package.json");
-        if (existsSync22(pkgPath)) {
-          version2 = JSON.parse(readFileSync22(pkgPath, "utf-8")).version;
+        const pkgPath = join34(__dirname2, "../package.json");
+        if (existsSync23(pkgPath)) {
+          version2 = JSON.parse(readFileSync23(pkgPath, "utf-8")).version;
         }
       } catch {}
       const report = {
@@ -56827,8 +57352,8 @@ var init_mcp_server = __esm(() => {
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
   __dirname2 = dirname9(__filename2);
-  CLAUDISH_CACHE_DIR = join33(homedir30(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join33(CLAUDISH_CACHE_DIR, "all-models.json");
+  CLAUDISH_CACHE_DIR = join34(homedir31(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join34(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",
@@ -56855,7 +57380,7 @@ var exports_serve_command = {};
 __export(exports_serve_command, {
   serveCommand: () => serveCommand
 });
-import { existsSync as existsSync23, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync24 } from "fs";
 function parseServeArgs(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -56874,12 +57399,12 @@ function parseServeArgs(args) {
   return out;
 }
 function loadModelMap(path) {
-  if (!existsSync23(path)) {
+  if (!existsSync24(path)) {
     throw new Error(`--models file not found: ${path}`);
   }
   let raw2;
   try {
-    raw2 = readFileSync23(path, "utf-8");
+    raw2 = readFileSync24(path, "utf-8");
   } catch (e) {
     throw new Error(`failed to read --models file ${path}: ${e instanceof Error ? e.message : String(e)}`);
   }
@@ -57194,7 +57719,7 @@ var exports_behavior_command = {};
 __export(exports_behavior_command, {
   behaviorCommand: () => behaviorCommand
 });
-import { existsSync as existsSync24, readFileSync as readFileSync24, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync25, writeFileSync as writeFileSync15 } from "fs";
 function severityColor(sev) {
   if (sev === "fix")
     return green(sev);
@@ -57292,8 +57817,8 @@ function setTelemetryEnabled(value) {
   const path = getConfigPath();
   let cfg = {};
   try {
-    if (existsSync24(path)) {
-      const parsed = JSON.parse(readFileSync24(path, "utf-8"));
+    if (existsSync25(path)) {
+      const parsed = JSON.parse(readFileSync25(path, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         cfg = parsed;
       }
@@ -57314,8 +57839,8 @@ function showTelemetry(action, json2) {
   let pending = 0;
   try {
     const path = outboxPath();
-    if (existsSync24(path)) {
-      pending = readFileSync24(path, "utf8").split(`
+    if (existsSync25(path)) {
+      pending = readFileSync25(path, "utf8").split(`
 `).filter(Boolean).length;
     }
   } catch {}
@@ -57400,9 +57925,9 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn4 } from "child_process";
 import { execSync } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync25, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync26, writeFileSync as writeFileSync16 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname10, join as join34 } from "path";
+import { dirname as dirname10, join as join35 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveRouteInfo(modelId) {
@@ -57496,18 +58021,18 @@ function buildPaneHeader(model, prompt, bg) {
 function findMagmuxBinary() {
   const thisFile = fileURLToPath2(import.meta.url);
   const thisDir = dirname10(thisFile);
-  const pkgRoot = join34(thisDir, "..");
+  const pkgRoot = join35(thisDir, "..");
   const platform2 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join34(pkgRoot, "native", `magmux-${platform2}-${arch}`);
-  if (existsSync25(bundledMagmux))
+  const bundledMagmux = join35(pkgRoot, "native", `magmux-${platform2}-${arch}`);
+  if (existsSync26(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform2}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join34(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync25(candidate))
+      const candidate = join35(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync26(candidate))
         return candidate;
       const parent = dirname10(searchDir);
       if (parent === searchDir)
@@ -57531,7 +58056,7 @@ function withoutControlPanes(evt) {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync25(sockPath)) {
+    if (existsSync26(sockPath)) {
       try {
         client = await new Promise((resolve6, reject) => {
           const s = netConnect(sockPath);
@@ -57618,9 +58143,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 = join34(sessionPath, "gridfile.txt");
-  const prompt = readFileSync25(join34(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync25(join34(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join35(sessionPath, "gridfile.txt");
+  const prompt = readFileSync26(join35(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync26(join35(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -57651,7 +58176,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 = join34(sessionPath, "status.json");
+  const statusPath = join35(sessionPath, "status.json");
   writeFileSync16(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
@@ -57676,8 +58201,8 @@ var exports_team_cli = {};
 __export(exports_team_cli, {
   teamCommand: () => teamCommand
 });
-import { readFileSync as readFileSync26 } from "fs";
-import { join as join35 } from "path";
+import { readFileSync as readFileSync27 } from "fs";
+import { join as join36 } from "path";
 function getFlag(args, flag) {
   const idx = args.indexOf(flag);
   if (idx === -1 || idx + 1 >= args.length)
@@ -57800,7 +58325,7 @@ async function teamCommand(args) {
     }
     case "judge": {
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync26(join35(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync27(join36(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -57818,7 +58343,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync26(join35(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync27(join36(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -58468,7 +58993,7 @@ var init_theme = __esm(() => {
 });
 
 // ../../node_modules/.bun/@inquirer+core@11.0.1+04f2146be16c61ef/node_modules/@inquirer/core/dist/lib/make-theme.js
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   if (typeof value !== "object" || value === null)
     return false;
   let proto = value;
@@ -58482,7 +59007,7 @@ function deepMerge(...objects) {
   for (const obj of objects) {
     for (const [key, value] of Object.entries(obj)) {
       const prevValue = output[key];
-      output[key] = isPlainObject3(prevValue) && isPlainObject3(value) ? deepMerge(prevValue, value) : value;
+      output[key] = isPlainObject4(prevValue) && isPlainObject4(value) ? deepMerge(prevValue, value) : value;
     }
   }
   return output;
@@ -69245,7 +69770,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 spawn5, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync27, unlinkSync as unlinkSync6, writeFileSync as writeFileSync17 } from "fs";
+import { readFileSync as readFileSync28, unlinkSync as unlinkSync6, writeFileSync as writeFileSync17 } from "fs";
 import path from "path";
 import os from "os";
 import { randomUUID as randomUUID5 } from "crypto";
@@ -69361,7 +69886,7 @@ class ExternalEditor {
   }
   readTemporaryFile() {
     try {
-      const tempFileBuffer = readFileSync27(this.tempFile);
+      const tempFileBuffer = readFileSync28(this.tempFile);
       if (tempFileBuffer.length === 0) {
         this.text = "";
       } else {
@@ -70756,9 +71281,9 @@ var init_keychain_command = __esm(() => {
 
 // src/auth/antigravity-oauth.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync26, unlinkSync as unlinkSync7 } from "fs";
-import { homedir as homedir31 } from "os";
-import { join as join36 } from "path";
+import { existsSync as existsSync27, unlinkSync as unlinkSync7 } from "fs";
+import { homedir as homedir32 } from "os";
+import { join as join37 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -70879,8 +71404,8 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps2) {
     deleteSharedAntigravityToken(deps2);
     try {
-      const tokenFile = join36(homedir31(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
-      if (existsSync26(tokenFile))
+      const tokenFile = join37(homedir32(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      if (existsSync27(tokenFile))
         unlinkSync7(tokenFile);
     } catch {}
     log("[AntigravityOAuth] Antigravity session cleared (keychain + agy token file)");
@@ -72282,6 +72807,23 @@ var init_model_selector = __esm(() => {
   };
 });
 
+// src/providers/probe-runner.ts
+function pinProbeModelSpec(link) {
+  if (link.provider === "native-anthropic")
+    return link.modelSpec;
+  return link.modelSpec.includes("@") ? link.modelSpec : `${link.provider}@${link.modelSpec}`;
+}
+function probeProviderRoute(proxyUrl, link, timeoutMs) {
+  return probeLink(proxyUrl, {
+    ...link,
+    modelSpec: pinProbeModelSpec(link)
+  }, timeoutMs);
+}
+var INTERACTIVE_PROBE_TIMEOUT_MS = 60000;
+var init_probe_runner = __esm(() => {
+  init_probe_live();
+});
+
 // src/tui/theme.ts
 import { createTextAttributes } from "@opentui/core";
 function latencyBucket(ms) {
@@ -72905,7 +73447,7 @@ function buildDirectRowData(result) {
     {
       num: "1",
       provider: result.nativeProvider,
-      spec: `${result.nativeProvider}@${result.model}`,
+      spec: pinProbeModelSpec({ provider: result.nativeProvider, modelSpec: result.model }),
       status,
       errorDetail,
       barsTiming
@@ -73238,6 +73780,7 @@ function printProbeResults(results, isLiveProbe) {
 var pc, ANSI_RE2, PRINTER_BAR_WIDTH = 24, PRINTER_TOK_WIDTH = 14, PRINTER_TRACK = "\xB7", PRINTER_BAR_FILL = "\u2588", STAGE_NUM_W = 6, PRINTER_TOK_VALUE_W = 9, PRINTER_BARS_FULL_WIDTH, PRINTER_BARS_NOTOK_WIDTH, PRINTER_BARS_MIN_WIDTH, MIN_CARD_WIDTH = 60, CARD_PADDING_LEFT = 2, CARD_PADDING_RIGHT = 2;
 var init_probe_results_printer = __esm(() => {
   init_probe_live();
+  init_probe_runner();
   init_ansi();
   init_theme_mode();
   init_theme2();
@@ -74711,23 +75254,6 @@ var init_claude_code_aliases = __esm(() => {
   };
 });
 
-// src/providers/probe-runner.ts
-function pinProbeModelSpec(link) {
-  if (link.provider === "native-anthropic")
-    return link.modelSpec;
-  return link.modelSpec.includes("@") ? link.modelSpec : `${link.provider}@${link.modelSpec}`;
-}
-function probeProviderRoute(proxyUrl, link, timeoutMs) {
-  return probeLink(proxyUrl, {
-    ...link,
-    modelSpec: pinProbeModelSpec(link)
-  }, timeoutMs);
-}
-var INTERACTIVE_PROBE_TIMEOUT_MS = 60000;
-var init_probe_runner = __esm(() => {
-  init_probe_live();
-});
-
 // src/cli.ts
 var exports_cli = {};
 __export(exports_cli, {
@@ -74744,30 +75270,30 @@ __export(exports_cli, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync27,
+  existsSync as existsSync28,
   mkdirSync as mkdirSync16,
-  readFileSync as readFileSync28,
-  readdirSync as readdirSync6,
+  readFileSync as readFileSync29,
+  readdirSync as readdirSync7,
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync18
 } from "fs";
-import { homedir as homedir32 } from "os";
-import { dirname as dirname11, join as join37 } from "path";
+import { homedir as homedir33 } from "os";
+import { dirname as dirname11, join as join38 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join37(homedir32(), ".claudish");
-  if (!existsSync27(cacheDir))
+  const cacheDir = join38(homedir33(), ".claudish");
+  if (!existsSync28(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
   try {
-    const files = readdirSync6(cacheDir);
+    const files = readdirSync7(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync8(join37(cacheDir, file2));
+        unlinkSync8(join38(cacheDir, file2));
         cleared++;
       }
     }
@@ -74987,6 +75513,33 @@ async function parseArgs(args) {
         process.exit(1);
       }
       config3.classifierProvider = cpArg;
+    } else if (arg === "--model-params") {
+      const mpArg = args[++i];
+      if (!mpArg) {
+        console.error("--model-params requires k=v[,k=v...] (e.g. reasoning.mode=pro)");
+        process.exit(1);
+      }
+      try {
+        config3.modelParams = parseModelParams(mpArg, config3.modelParams ?? {});
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    } else if (arg === "--effort-override") {
+      const effArg = args[++i];
+      if (!effArg) {
+        console.error(`--effort-override requires a level (${EFFORT_LEVELS.join(", ")})`);
+        process.exit(1);
+      }
+      if (!isEffortLevel(effArg)) {
+        console.error(`--effort-override "${effArg}" is not a canonical level (${EFFORT_LEVELS.join(", ")}). ` + "For a provider-specific value, use --model-params (e.g. --model-params reasoning_effort=<value>).");
+        process.exit(1);
+      }
+      config3.effortOverride = effArg;
+    } else if (arg === "--pro-on-ultracode") {
+      config3.proOnUltracode = true;
+    } else if (arg === "--no-pro-on-ultracode") {
+      config3.proOnUltracode = false;
     } else if (arg === "--op-env" || arg.startsWith("--op-env=")) {
       const v = arg.startsWith("--op-env=") ? arg.slice("--op-env=".length) : args[++i];
       if (!v) {
@@ -75197,8 +75750,8 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join37(homedir32(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync27(markerFile)) {
+      const markerFile = join38(homedir33(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync28(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
@@ -75210,6 +75763,14 @@ Usage:  claudish --models --provider <slug>`);
       }
     }
   } catch {}
+  if (config3.proOnUltracode === undefined) {
+    const envVal = process.env.CLAUDISH_PRO_ON_ULTRACODE;
+    if (envVal !== undefined) {
+      config3.proOnUltracode = envVal === "1" || envVal.toLowerCase() === "true";
+    } else {
+      config3.proOnUltracode = readProOnUltracode() === true;
+    }
+  }
   return config3;
 }
 function formatModelDocPricing(pricing) {
@@ -75805,14 +76366,14 @@ async function probeModelRouting(models, jsonOutput, options = { live: true, tim
     }
     return;
   }
-  const initialState = {
+  const initialState2 = {
     steps: [],
     links: [],
     phase: "live",
     results: [],
     activeTab: "summary"
   };
-  const tui = await startProbeTui(initialState);
+  const tui = await startProbeTui(initialState2);
   const addStep = (name, status) => {
     tui.store.setState((prev) => ({
       ...prev,
@@ -76106,6 +76667,10 @@ ${h("OPTIONS")}
   ${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("--model-params")} ${yellow2('"k=v,..."')}  Extra request params merged into the payload (e.g. reasoning.mode=pro)
+  ${green2("--effort-override")} ${yellow2("<level>")}  Pin reasoning effort verbatim, skipping the per-model clamp
+  ${green2("--pro-on-ultracode")}       Apply the model's catalog preset while in ultracode (opt-in)
+  ${green2("--no-pro-on-ultracode")}    Force that off for this run (when enabled in config/env)
   ${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
@@ -76317,8 +76882,8 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join37(__dirname3, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync28(guidePath, "utf-8");
+    const guidePath = join38(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync29(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -76334,19 +76899,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join37(cwd, ".claude");
-  const skillsDir = join37(claudeDir, "skills");
-  const claudishSkillDir = join37(skillsDir, "claudish-usage");
-  const skillFile = join37(claudishSkillDir, "SKILL.md");
-  if (existsSync27(skillFile)) {
+  const claudeDir = join38(cwd, ".claude");
+  const skillsDir = join38(claudeDir, "skills");
+  const claudishSkillDir = join38(skillsDir, "claudish-usage");
+  const skillFile = join38(claudishSkillDir, "SKILL.md");
+  if (existsSync28(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join37(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync27(sourceSkillPath)) {
+  const sourceSkillPath = join38(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync28(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -76355,15 +76920,15 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync27(claudeDir)) {
+    if (!existsSync28(claudeDir)) {
       mkdirSync16(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync27(skillsDir)) {
+    if (!existsSync28(skillsDir)) {
       mkdirSync16(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync27(claudishSkillDir)) {
+    if (!existsSync28(claudishSkillDir)) {
       mkdirSync16(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
@@ -76421,6 +76986,7 @@ function printAvailableModels() {
 }
 var __filename3, __dirname3;
 var init_cli = __esm(() => {
+  init_base_api_format();
   init_config2();
   init_model_loader();
   init_model_selector();
@@ -76452,33 +77018,33 @@ __export(exports_update_checker, {
   fetchLatestVersion: () => fetchLatestVersion,
   fetchLatestVersionOrThrow: () => fetchLatestVersionOrThrow
 });
-import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync29, unlinkSync as unlinkSync9, writeFileSync as writeFileSync19 } from "fs";
-import { homedir as homedir33, platform as platform2, tmpdir } from "os";
-import { join as join38 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync30, unlinkSync as unlinkSync9, writeFileSync as writeFileSync19 } from "fs";
+import { homedir as homedir34, platform as platform2, tmpdir } from "os";
+import { join as join39 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join38(homedir33(), "AppData", "Local");
-    cacheDir = join38(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join39(homedir34(), "AppData", "Local");
+    cacheDir = join39(localAppData, "claudish");
   } else {
-    cacheDir = join38(homedir33(), ".cache", "claudish");
+    cacheDir = join39(homedir34(), ".cache", "claudish");
   }
   try {
-    if (!existsSync28(cacheDir)) {
+    if (!existsSync29(cacheDir)) {
       mkdirSync17(cacheDir, { recursive: true });
     }
-    return join38(cacheDir, "update-check.json");
+    return join39(cacheDir, "update-check.json");
   } catch {
-    return join38(tmpdir(), "claudish-update-check.json");
+    return join39(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync28(cachePath)) {
+    if (!existsSync29(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync29(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync30(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -76501,7 +77067,7 @@ function isCacheValid(cache3) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync28(cachePath)) {
+    if (existsSync29(cachePath)) {
       unlinkSync9(cachePath);
     }
   } catch {}
@@ -77405,15 +77971,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync18, readFileSync as readFileSync30, writeFileSync as writeFileSync20 } from "fs";
-import { homedir as homedir34 } from "os";
-import { dirname as dirname12, join as join39 } from "path";
+import { existsSync as existsSync30, mkdirSync as mkdirSync18, readFileSync as readFileSync31, writeFileSync as writeFileSync20 } from "fs";
+import { homedir as homedir35 } from "os";
+import { dirname as dirname12, join as join40 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
-  if (!existsSync29(path2))
+  if (!existsSync30(path2))
     return null;
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync30(path2, "utf-8"));
+    raw2 = JSON.parse(readFileSync31(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -77542,7 +78108,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 = join39(homedir34(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join40(homedir35(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -84145,18 +84711,18 @@ __export(exports_claude_runner, {
 });
 import { spawn as spawn6, spawnSync as spawnSync5 } from "child_process";
 import {
-  closeSync as closeSync7,
-  existsSync as existsSync30,
+  closeSync as closeSync8,
+  existsSync as existsSync31,
   mkdirSync as mkdirSync19,
-  openSync as openSync7,
-  readFileSync as readFileSync31,
-  readdirSync as readdirSync7,
-  statSync as statSync7,
+  openSync as openSync8,
+  readFileSync as readFileSync32,
+  readdirSync as readdirSync8,
+  statSync as statSync8,
   unlinkSync as unlinkSync10,
   writeFileSync as writeFileSync21
 } from "fs";
-import { homedir as homedir35, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname13, join as join40 } from "path";
+import { homedir as homedir36, tmpdir as tmpdir2 } from "os";
+import { dirname as dirname13, join as join41 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -84195,11 +84761,11 @@ function shouldHideIncidentalAnthropicKey(config3, env = process.env) {
 }
 function hasResolvableAnthropicAuth(deps2 = {}) {
   const env = deps2.env ?? process.env;
-  const fileExists = deps2.fileExists ?? existsSync30;
+  const fileExists = deps2.fileExists ?? existsSync31;
   const keychainProbe = deps2.keychainProbe ?? defaultKeychainAnthropicProbe;
   if (env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN)
     return true;
-  if (fileExists(join40(homedir35(), ".claude", ".credentials.json")))
+  if (fileExists(join41(homedir36(), ".claude", ".credentials.json")))
     return true;
   return keychainProbe();
 }
@@ -84211,14 +84777,14 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join40(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join41(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(readFile3 = readFileSync31) {
+function managedSettingsForcesClaudeAi(readFile3 = readFileSync32) {
   try {
     const raw2 = readFile3(managedSettingsPath(), "utf-8");
     const parsed = JSON.parse(raw2);
@@ -84232,9 +84798,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join40(homeDir, ".claudish");
+  const claudishDir = join41(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join40(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join41(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const light = getThemeMode() === "light";
   const cyanCode = light ? "38;2;14;116;144" : "96";
@@ -84392,7 +84958,7 @@ function cleanupStaleTokenFiles(dir, now2 = Date.now(), maxAgeMs = STALE_TOKEN_F
   let removed = 0;
   let entries;
   try {
-    entries = readdirSync7(dir);
+    entries = readdirSync8(dir);
   } catch {
     return 0;
   }
@@ -84404,9 +84970,9 @@ function cleanupStaleTokenFiles(dir, now2 = Date.now(), maxAgeMs = STALE_TOKEN_F
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join40(dir, name);
+    const full = join41(dir, name);
     try {
-      if (statSync7(full).mtimeMs >= cutoff)
+      if (statSync8(full).mtimeMs >= cutoff)
         continue;
       unlinkSync10(full);
       removed++;
@@ -84421,7 +84987,7 @@ function parseSettingsArg(value) {
   if (value.trimStart().startsWith("{")) {
     return JSON.parse(value);
   }
-  return JSON.parse(readFileSync31(value, "utf-8"));
+  return JSON.parse(readFileSync32(value, "utf-8"));
 }
 function parseSettingsArgSafe(value) {
   try {
@@ -84433,13 +84999,13 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join40(homedir35(), ".claude", "settings.json"),
-    join40(cwd, ".claude", "settings.json"),
-    join40(cwd, ".claude", "settings.local.json")
+    join41(homedir36(), ".claude", "settings.json"),
+    join41(cwd, ".claude", "settings.json"),
+    join41(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
-  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync30(file2));
+  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync31(file2));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
@@ -84476,13 +85042,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join40(homeDir, ".claudish");
+  const claudishDir = join41(homeDir, ".claudish");
   try {
     mkdirSync19(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join40(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join40(claudishDir, `tokens-${port}.json`);
+  const tempPath = join41(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join41(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -84736,8 +85302,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 = homedir35();
-    const localPath = isWindows2() ? join40(home, ".claude", "local", "claude.exe") : join40(home, ".claude", "local", "claude");
+    const home = homedir36();
+    const localPath = isWindows2() ? join41(home, ".claude", "local", "claude.exe") : join41(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -84748,11 +85314,11 @@ Or set CLAUDE_PATH to your custom installation:`);
   const childWantsTty = config3.interactive && !process.stdout.isTTY && Boolean(process.stdin.isTTY);
   if (childWantsTty) {
     try {
-      const fd = openSync7("/dev/fd/0", "r+");
+      const fd = openSync8("/dev/fd/0", "r+");
       if (isatty(fd)) {
         ttyFd = fd;
       } else {
-        closeSync7(fd);
+        closeSync8(fd);
       }
     } catch {
       ttyFd = undefined;
@@ -84775,7 +85341,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     const fdToClose = ttyFd;
     proc.on("spawn", () => {
       try {
-        closeSync7(fdToClose);
+        closeSync8(fdToClose);
       } catch {}
     });
   }
@@ -84817,23 +85383,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync30(process.env.CLAUDE_PATH)) {
+    if (existsSync31(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir35();
-  const localPath = isWindows3 ? join40(home, ".claude", "local", "claude.exe") : join40(home, ".claude", "local", "claude");
-  if (existsSync30(localPath)) {
+  const home = homedir36();
+  const localPath = isWindows3 ? join41(home, ".claude", "local", "claude.exe") : join41(home, ".claude", "local", "claude");
+  if (existsSync31(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join40(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join40(home, ".npm-global", "claude.cmd"),
-      join40(home, "node_modules", ".bin", "claude.cmd")
+      join41(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join41(home, ".npm-global", "claude.cmd"),
+      join41(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync30(path2)) {
+      if (existsSync31(path2)) {
         return path2;
       }
     }
@@ -84841,14 +85407,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join40(home, ".npm-global/bin/claude"),
-      join40(home, ".local/bin/claude"),
-      join40(home, "node_modules/.bin/claude"),
+      join41(home, ".npm-global/bin/claude"),
+      join41(home, ".local/bin/claude"),
+      join41(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join40(home, "../usr/bin/claude")
+      join41(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync30(path2)) {
+      if (existsSync31(path2)) {
         return path2;
       }
     }
@@ -84929,17 +85495,17 @@ __export(exports_diag_output, {
   createDiagOutput: () => createDiagOutput
 });
 import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync20, unlinkSync as unlinkSync11, writeFileSync as writeFileSync22 } from "fs";
-import { homedir as homedir36 } from "os";
-import { join as join41 } from "path";
+import { homedir as homedir37 } from "os";
+import { join as join42 } from "path";
 function getClaudishDir() {
-  const dir = join41(homedir36(), ".claudish");
+  const dir = join42(homedir37(), ".claudish");
   try {
     mkdirSync20(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join41(getClaudishDir(), `diag-${process.pid}.log`);
+  return join42(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -85544,7 +86110,7 @@ var init_widgets = __esm(() => {
 });
 
 // src/session/conversation.ts
-import { closeSync as closeSync8, openSync as openSync8, readSync as readSync3, statSync as statSync8 } from "fs";
+import { closeSync as closeSync9, openSync as openSync9, readSync as readSync4, statSync as statSync9 } from "fs";
 import { StringDecoder as StringDecoder2 } from "string_decoder";
 function looksLikeTurn(line) {
   const assistant = line.includes('"type":"assistant"');
@@ -85599,8 +86165,8 @@ function readConversation(file2, opts = {}) {
   };
   let fd = null;
   try {
-    const size = statSync8(file2).size;
-    fd = openSync8(file2, "r");
+    const size = statSync9(file2).size;
+    fd = openSync9(file2, "r");
     const buf = Buffer.allocUnsafe(chunkBytes);
     const decoder = new StringDecoder2("utf-8");
     let pending = "";
@@ -85632,7 +86198,7 @@ function readConversation(file2, opts = {}) {
       take({ role: raw2.role, text, elided });
     };
     while (pos < size) {
-      const n = readSync3(fd, buf, 0, Math.min(chunkBytes, size - pos), pos);
+      const n = readSync4(fd, buf, 0, Math.min(chunkBytes, size - pos), pos);
       if (n <= 0)
         break;
       pos += n;
@@ -85656,7 +86222,7 @@ function readConversation(file2, opts = {}) {
   } catch {} finally {
     if (fd !== null) {
       try {
-        closeSync8(fd);
+        closeSync9(fd);
       } catch {}
     }
   }
@@ -87263,16 +87829,16 @@ __export(exports_session_stats, {
   readSessionStats: () => readSessionStats,
   tokenFilePath: () => tokenFilePath
 });
-import { readFileSync as readFileSync32 } from "fs";
-import { homedir as homedir37 } from "os";
-import { join as join42 } from "path";
+import { readFileSync as readFileSync33 } from "fs";
+import { homedir as homedir38 } from "os";
+import { join as join43 } from "path";
 function tokenFilePath(port) {
-  return process.env.CLAUDISH_TOKEN_FILE || join42(homedir37(), ".claudish", `tokens-${port}.json`);
+  return process.env.CLAUDISH_TOKEN_FILE || join43(homedir38(), ".claudish", `tokens-${port}.json`);
 }
 function readSessionStats(port, opts) {
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync32(tokenFilePath(port), "utf-8"));
+    raw2 = JSON.parse(readFileSync33(tokenFilePath(port), "utf-8"));
   } catch {
     return null;
   }
@@ -87611,8 +88177,8 @@ var init_session_summary = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync31, readFileSync as readFileSync33 } from "fs";
-import { join as join43, resolve as resolve6 } from "path";
+import { existsSync as existsSync32, readFileSync as readFileSync34 } from "fs";
+import { join as join44, resolve as resolve6 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -87712,7 +88278,7 @@ async function applyConfigOverride() {
   const { planConfigOverride: planConfigOverride2, setConfigFileOverride: setConfigFileOverride2 } = await Promise.resolve().then(() => exports_config_override);
   const plan = planConfigOverride2(process.argv.slice(2), process.env, {
     resolve: resolve6,
-    exists: existsSync31
+    exists: existsSync32
   });
   if (plan.kind === "none")
     return;
@@ -87885,14 +88451,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync33(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync34(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 = join43(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join44(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);
@@ -87902,9 +88468,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join43(sessionPath, `response-${anonId}.md`);
+          const responsePath = join44(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync33(responsePath, "utf-8").trim();
+            const raw2 = readFileSync34(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {
@@ -88110,7 +88676,10 @@ Team Status`);
       advisorModels: cliConfig.advisorModels,
       advisorCollector: cliConfig.advisorCollector,
       modelChain: cliConfig.monitor ? undefined : cliConfig.modelChain,
-      classifier: resolveClassifierConfig(cliConfig, process.env)
+      classifier: resolveClassifierConfig(cliConfig, process.env),
+      effortOverride: cliConfig.effortOverride,
+      modelParams: cliConfig.modelParams,
+      proOnUltracode: cliConfig.proOnUltracode
     }));
     const diag = createDiagOutput2({
       interactive: cliConfig.interactive,