claudish 9.2.1 → 9.3.0

package/dist/index.js

@@ -715,7 +715,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "9.2.1";
+var VERSION = "9.3.0";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -20992,6 +20992,11 @@ function messageStartUsage(priorInputTokens) {
 }
 
 // src/handlers/shared/stream-parsers/openai-sse.ts
+function formatRawSseLogPayload(dataStr) {
+  if (dataStr.length <= SSE_LOG_MAX_CHARS)
+    return dataStr;
+  return `${dataStr.substring(0, SSE_LOG_MAX_CHARS)} ${SSE_LOG_TRUNCATION_MARKER} original_chars=${dataStr.length}`;
+}
 function validateToolArguments(toolName, argsStr, toolSchemas, textContent) {
   const result = validateAndRepairToolCall(toolName, argsStr, toolSchemas, textContent);
   if (result.repaired) {
@@ -21253,7 +21258,7 @@ data: ${JSON.stringify(d)}
             if (!line.trim() || !line.startsWith("data: "))
               continue;
             const dataStr = line.slice(6);
-            log(`[SSE:openai] ${dataStr.substring(0, 300)}`);
+            log(`[SSE:openai] ${formatRawSseLogPayload(dataStr)}`);
             if (dataStr === "[DONE]") {
               await finalize("done");
               return;
@@ -21539,6 +21544,7 @@ data: ${JSON.stringify(d)}
     }
   });
 }
+var SSE_LOG_MAX_CHARS = 1e6, SSE_LOG_TRUNCATION_MARKER = "<<<CLAUDISH_SSE_TRUNCATED>>>";
 var init_openai_sse = __esm(() => {
   init_logger();
   init_tool_call_recovery();
@@ -33657,7 +33663,7 @@ data: ${JSON.stringify(data)}
             if (data === "[DONE]")
               continue;
             if (getLogLevel() === "debug") {
-              log(`[SSE:responses] ${data.substring(0, 300)}`);
+              log(`[SSE:responses] ${formatRawSseLogPayload(data)}`);
             }
             try {
               const event = JSON.parse(data);
@@ -33921,6 +33927,7 @@ var init_openai_responses_sse = __esm(() => {
   init_reasoning_cache();
   init_logger();
   init_anthropic_error();
+  init_openai_sse();
 });
 
 // src/handlers/shared/token-tracker.ts
@@ -44812,166 +44819,6 @@ ${text}`;
   };
 });
 
-// src/handlers/fallback-handler.ts
-class FallbackHandler {
-  candidates;
-  lastSuccessIndex = 0;
-  constructor(candidates) {
-    this.candidates = candidates;
-  }
-  async handle(c, payload) {
-    const errors = [];
-    const startIndex = this.lastSuccessIndex;
-    for (let attempt = 0;attempt < this.candidates.length; attempt++) {
-      const idx = (startIndex + attempt) % this.candidates.length;
-      const { name, handler } = this.candidates[idx];
-      const isLast = attempt === this.candidates.length - 1;
-      try {
-        if (errors.length > 0 && handler instanceof ComposedHandler) {
-          try {
-            handler.setFallbackMeta(this.candidates.map((c) => c.name), errors.length);
-          } catch {}
-        }
-        const response = await handler.handle(c, payload);
-        if (response.ok) {
-          this.lastSuccessIndex = idx;
-          if (errors.length > 0) {
-            logStderr(`[Fallback] ${name} succeeded after ${errors.length} failed attempt(s)`);
-            if (handler instanceof ComposedHandler) {
-              handler.getTokenTracker()?.setProviderDisplayName(name);
-            }
-          }
-          return response;
-        }
-        const errorBody = await response.clone().text();
-        if (!isRetryableError(response.status, errorBody, name)) {
-          if (errors.length > 0) {
-            errors.push({ provider: name, status: response.status, message: errorBody });
-            return this.formatCombinedError(c, errors, payload.model);
-          }
-          return response;
-        }
-        errors.push({ provider: name, status: response.status, message: errorBody });
-        if (!isLast) {
-          if (hasQuotaExhaustionWording(errorBody)) {
-            logStderr(`[Fallback] ${name} subscription allowance is spent \u2014 falling through to the next provider, which is billed PER TOKEN. Use a provider prefix (e.g. \`zgo@model\`) to fail instead of switching.`);
-          } else {
-            logStderr(`[Fallback] ${name} failed (HTTP ${response.status}), trying next provider...`);
-          }
-        }
-      } catch (err) {
-        errors.push({ provider: name, status: 0, message: err.message });
-        if (!isLast) {
-          logStderr(`[Fallback] ${name} error: ${err.message}, trying next provider...`);
-        }
-      }
-    }
-    return this.formatCombinedError(c, errors, payload.model);
-  }
-  formatCombinedError(c, errors, modelName) {
-    const summary = errors.map((e) => `  ${e.provider}: HTTP ${e.status || "ERR"} \u2014 ${truncate(parseErrorMessage(e.message), 150)}`).join(`
-`);
-    logStderr(`[Fallback] All ${errors.length} provider(s) failed for ${modelName || "model"}:
-${summary}`);
-    return c.json({
-      error: {
-        type: "all_providers_failed",
-        message: `All ${errors.length} providers failed for model '${modelName || "unknown"}'`,
-        attempts: errors.map((e) => ({
-          provider: e.provider,
-          status: e.status,
-          error: truncate(parseErrorMessage(e.message), 200)
-        }))
-      }
-    }, exhaustedChainStatus(errors));
-  }
-  async shutdown() {
-    for (const { handler } of this.candidates) {
-      if (typeof handler.shutdown === "function") {
-        await handler.shutdown();
-      }
-    }
-  }
-}
-function isRetryableError(status, errorBody, provider) {
-  if (hasQuotaExhaustionWording(errorBody))
-    return true;
-  const upstream = status === 400 ? extractUpstreamStatus(errorBody) : undefined;
-  if (upstream === 401 || upstream === 403 || upstream === 402 || upstream === 429) {
-    return true;
-  }
-  if (status === 401 || status === 403)
-    return true;
-  if (status === 402)
-    return true;
-  if (status === 404)
-    return true;
-  if (status === 429)
-    return true;
-  const lower = errorBody.toLowerCase();
-  if (status === 422) {
-    if (lower.includes("not available") || lower.includes("model not found") || lower.includes("not supported")) {
-      return true;
-    }
-  }
-  if (status === 400) {
-    if (lower.includes("model not found") || lower.includes("not registered") || lower.includes("does not exist") || lower.includes("unknown model") || lower.includes("unsupported model") || lower.includes("no healthy deployment") || lower.includes("requires a google cloud project") || lower.includes("unsupported_client")) {
-      return true;
-    }
-    if (provider?.toLowerCase().includes("antigravity") && lower.includes("invalid argument")) {
-      return true;
-    }
-    if (isProvider(provider, "opencodezen") && (lower.includes("upstream request failed") || lower.includes("error from provider ("))) {
-      return true;
-    }
-  }
-  if (status === 500) {
-    if (lower.includes("insufficient balance") || lower.includes("insufficient credit") || lower.includes("quota exceeded") || lower.includes("billing")) {
-      return true;
-    }
-  }
-  return false;
-}
-function exhaustedChainStatus(errors) {
-  if (errors.length === 0)
-    return 400;
-  const isTransient = (e) => {
-    if (e.status === 429 || e.status === 503)
-      return true;
-    if (hasQuotaExhaustionWording(e.message))
-      return true;
-    const upstream = e.status === 400 ? extractUpstreamStatus(e.message) : undefined;
-    return upstream === 429 || upstream === 503;
-  };
-  return errors.every(isTransient) ? 503 : 400;
-}
-function isProvider(provider, needle) {
-  if (!provider)
-    return false;
-  return provider.toLowerCase().replace(/[^a-z0-9]/g, "").includes(needle);
-}
-function parseErrorMessage(body) {
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed.error === "string")
-      return parsed.error;
-    if (typeof parsed.error?.message === "string")
-      return parsed.error.message;
-    if (typeof parsed.message === "string")
-      return parsed.message;
-  } catch {}
-  return body;
-}
-function truncate(s, max) {
-  return s.length > max ? `${s.slice(0, max)}...` : s;
-}
-var init_fallback_handler = __esm(() => {
-  init_logger();
-  init_composed_handler();
-  init_anthropic_error();
-  init_quota_exhaustion();
-});
-
 // src/handlers/native-handler-advisor.ts
 import { appendFileSync as appendFileSync7 } from "fs";
 function loadAdvisorSwapConfig(cliModels, cliCollector) {
@@ -45022,17 +44869,65 @@ function stripAdvisorBeta(betaHeader) {
     changed: true
   };
 }
+function scrubSecrets(text) {
+  return text.replace(/Bearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, `Bearer ${REDACTED}`).replace(/\bsk-[A-Za-z0-9_-]{8,}/g, REDACTED).replace(/\bAIza[0-9A-Za-z_-]{20,}/g, REDACTED).replace(/\bxai-[A-Za-z0-9_-]{16,}/g, REDACTED);
+}
+function sanitizeAdvisorReason(text, secretValues = []) {
+  let out = text;
+  for (const secret of secretValues) {
+    const value = secret?.trim();
+    if (!value || value.length < MIN_REDACTABLE_SECRET_LENGTH)
+      continue;
+    out = out.split(value).join(REDACTED);
+  }
+  return scrubSecrets(out);
+}
+function credentialValuesInHeaders(headers) {
+  const values = [];
+  const bearer = headers.Authorization ?? headers.authorization;
+  if (bearer)
+    values.push(bearer.replace(/^Bearer\s+/i, "").trim());
+  const apiKey = headers["x-api-key"];
+  if (apiKey)
+    values.push(apiKey.trim());
+  return values;
+}
+function credentialValuesOf(apiKeys) {
+  return Object.values(apiKeys).filter((v) => typeof v === "string");
+}
 function logAdvisorEvent(cfg, event) {
+  const ts = new Date().toISOString();
+  const record = { ts, ...event };
+  let line;
+  try {
+    line = scrubSecrets(JSON.stringify(record));
+  } catch {
+    return;
+  }
+  if (typeof event.kind === "string" && ORIGIN_RECORD_KINDS.has(event.kind)) {
+    if (getLogFilePath() !== null)
+      log(`${ADVISOR_ORIGIN_LOG_PREFIX} ${line}`);
+    appendLine(getAlwaysOnLogPath(), `[${ts}] ${ADVISOR_ORIGIN_LOG_PREFIX} ${line}`);
+  }
+  appendLine(cfg.logPath, line);
+}
+function appendLine(path, line) {
+  if (!path)
+    return;
+  try {
+    appendFileSync7(path, `${line}
+`);
+  } catch {}
+}
+function recordAdvisorEventsFromResponseBody(cfg, body, sessionId) {
+  collectAdvisorIdsFromValue(body, 0, sessionId);
   if (!cfg.logPath)
     return;
-  const line = `${JSON.stringify({ ts: new Date().toISOString(), ...event })}
-`;
   try {
-    appendFileSync7(cfg.logPath, line);
+    logAdvisorMarkers(cfg, JSON.stringify(body));
   } catch {}
 }
-function recordAdvisorEventsFromChunk(cfg, chunkText) {
-  extractAdvisorToolUseIds(chunkText);
+function logAdvisorMarkers(cfg, text) {
   if (!cfg.logPath)
     return;
   const markers = [
@@ -45046,37 +44941,275 @@ function recordAdvisorEventsFromChunk(cfg, chunkText) {
   for (const [needle, kind] of markers) {
     let i = 0;
     while (true) {
-      i = chunkText.indexOf(needle, i);
+      i = text.indexOf(needle, i);
       if (i < 0)
         break;
-      const ctx = chunkText.slice(Math.max(0, i - 40), i + 160);
+      const ctx = text.slice(Math.max(0, i - 40), i + 160);
       logAdvisorEvent(cfg, { kind, needle, ctx });
       i += needle.length;
     }
   }
 }
-function extractAdvisorToolUseIds(chunkText) {
-  const re = /"type"\s*:\s*"tool_use"\s*,\s*"id"\s*:\s*"(toolu_[A-Za-z0-9_-]+)"\s*,\s*"name"\s*:\s*"advisor"/g;
-  let m;
-  while ((m = re.exec(chunkText)) !== null) {
-    rememberAdvisorToolUseId(m[1]);
+function warnAdvisor(message) {
+  logStderr(`[advisor] ${message}`);
+}
+function sessionKeyFor(sessionId) {
+  return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : NO_SESSION_BUCKET;
+}
+function isCallInFlight(toolUseId) {
+  return (inFlightByToolUseId.get(toolUseId) ?? 0) > 0;
+}
+function bucketHasInFlightCall(bucket) {
+  for (const id of bucket.keys())
+    if (isCallInFlight(id))
+      return true;
+  return false;
+}
+function isExpired(call, now) {
+  if (isCallInFlight(call.toolUseId))
+    return false;
+  return now - call.lastSeenAt > ADVISOR_PENDING_LIMITS.ttlMs;
+}
+function sweepExpiredIfDue() {
+  const now = clock();
+  if (now - lastSweepAt < SWEEP_INTERVAL_MS)
+    return;
+  lastSweepAt = now;
+  for (const [key, bucket] of pendingBySession) {
+    for (const [id, call] of bucket) {
+      if (isExpired(call, now))
+        bucket.delete(id);
+    }
+    if (bucket.size === 0)
+      pendingBySession.delete(key);
+  }
+}
+function touchBucket(key) {
+  const bucket = pendingBySession.get(key);
+  if (!bucket)
+    return;
+  pendingBySession.delete(key);
+  pendingBySession.set(key, bucket);
+  return bucket;
+}
+function bucketForWrite(key) {
+  const existing = touchBucket(key);
+  if (existing)
+    return existing;
+  const bucket = new Map;
+  pendingBySession.set(key, bucket);
+  while (pendingBySession.size > ADVISOR_PENDING_LIMITS.maxSessions) {
+    const evictable = [...pendingBySession].find(([k, b]) => k !== key && !bucketHasInFlightCall(b));
+    if (!evictable)
+      break;
+    pendingBySession.delete(evictable[0]);
+  }
+  return bucket;
+}
+function putCall(bucket, call) {
+  bucket.delete(call.toolUseId);
+  if (bucket.size >= ADVISOR_PENDING_LIMITS.maxCallsPerSession) {
+    const oldest = [...bucket.keys()].find((id) => !isCallInFlight(id));
+    if (oldest !== undefined)
+      bucket.delete(oldest);
+  }
+  bucket.set(call.toolUseId, call);
+}
+function rememberAdvisorToolUseId(id, sessionId) {
+  sweepExpiredIfDue();
+  const key = sessionKeyFor(sessionId);
+  const bucket = bucketForWrite(key);
+  const now = clock();
+  const existing = bucket.get(id);
+  if (existing) {
+    existing.lastSeenAt = now;
+    putCall(bucket, existing);
+    return;
+  }
+  putCall(bucket, { toolUseId: id, sessionKey: key, recordedAt: now, lastSeenAt: now });
+  log(`[advisor] recorded advisor tool_use ${id} (session=${key})`);
+}
+function lookupAdvisorCall(toolUseId, sessionId) {
+  sweepExpiredIfDue();
+  const now = clock();
+  const own = sessionKeyFor(sessionId);
+  const keys = own === NO_SESSION_BUCKET ? [NO_SESSION_BUCKET] : [own, NO_SESSION_BUCKET];
+  for (const key of keys) {
+    const bucket = pendingBySession.get(key);
+    const call = bucket?.get(toolUseId);
+    if (!bucket || !call)
+      continue;
+    if (isExpired(call, now)) {
+      bucket.delete(toolUseId);
+      continue;
+    }
+    call.lastSeenAt = now;
+    putCall(bucket, call);
+    touchBucket(key);
+    return call;
+  }
+  return;
+}
+function getAdvisorCall(toolUseId, sessionId) {
+  return lookupAdvisorCall(toolUseId, sessionId);
+}
+function markAdvisorCallConsumed(toolUseId, result, sessionId) {
+  const call = lookupAdvisorCall(toolUseId, sessionId);
+  if (!call)
+    return false;
+  const own = sessionKeyFor(sessionId);
+  if (call.sessionKey === NO_SESSION_BUCKET && own !== NO_SESSION_BUCKET) {
+    pendingBySession.get(NO_SESSION_BUCKET)?.delete(toolUseId);
+    call.sessionKey = own;
+    putCall(bucketForWrite(own), call);
+  }
+  call.consumedAt ??= clock();
+  call.result = result;
+  return true;
+}
+function joinOrStartAdvisorCall(toolUseId, sessionId, start) {
+  const key = `${sessionKeyFor(sessionId)}\x00${toolUseId}`;
+  const existing = inFlightAdvisorCalls.get(key);
+  if (existing)
+    return { promise: existing, joined: true };
+  while (inFlightAdvisorCalls.size >= MAX_IN_FLIGHT_ADVISOR_CALLS) {
+    const oldest = inFlightAdvisorCalls.keys().next().value;
+    if (oldest === undefined)
+      break;
+    inFlightAdvisorCalls.delete(oldest);
+  }
+  inFlightByToolUseId.set(toolUseId, (inFlightByToolUseId.get(toolUseId) ?? 0) + 1);
+  const release = () => {
+    const left = (inFlightByToolUseId.get(toolUseId) ?? 1) - 1;
+    if (left > 0)
+      inFlightByToolUseId.set(toolUseId, left);
+    else
+      inFlightByToolUseId.delete(toolUseId);
+  };
+  let started;
+  try {
+    started = start();
+  } catch (err) {
+    release();
+    throw err;
+  }
+  const promise = started.finally(() => {
+    release();
+    if (inFlightAdvisorCalls.get(key) === promise)
+      inFlightAdvisorCalls.delete(key);
+  });
+  inFlightAdvisorCalls.set(key, promise);
+  return { promise, joined: false };
+}
+
+class SseFrameBuffer {
+  buf = "";
+  take(chunkText) {
+    this.buf += chunkText;
+    const events = [];
+    while (true) {
+      const lf = this.buf.indexOf(`
+
+`);
+      const crlf = this.buf.indexOf(`\r
+\r
+`);
+      let idx = -1;
+      let width = 2;
+      if (crlf >= 0 && (lf < 0 || crlf < lf)) {
+        idx = crlf;
+        width = 4;
+      } else if (lf >= 0) {
+        idx = lf;
+      }
+      if (idx < 0)
+        break;
+      events.push(this.buf.slice(0, idx));
+      this.buf = this.buf.slice(idx + width);
+    }
+    if (this.buf.length > MAX_SSE_BUFFER_CHARS) {
+      this.buf = this.buf.slice(-MAX_SSE_BUFFER_CHARS);
+    }
+    return events;
+  }
+  reset() {
+    this.buf = "";
+  }
+}
+function createAdvisorStreamScanner(cfg, sessionId) {
+  const frames = new SseFrameBuffer;
+  return {
+    push(chunkText) {
+      extractAdvisorToolUseIds(chunkText, frames, sessionId);
+      logAdvisorMarkers(cfg, chunkText);
+    }
+  };
+}
+function extractAdvisorToolUseIds(chunkText, frames, sessionId) {
+  if (parseAdvisorIdsFromJsonText(chunkText, sessionId))
+    return;
+  let sawCompleteFrame = false;
+  for (const event of frames.take(chunkText)) {
+    sawCompleteFrame = true;
+    if (!scanSseEventForAdvisorIds(event, sessionId))
+      matchAdvisorIdsByRegex(event, sessionId);
+  }
+  if (!sawCompleteFrame)
+    matchAdvisorIdsByRegex(chunkText, sessionId);
+}
+function scanSseEventForAdvisorIds(rawEvent, sessionId) {
+  const dataLines = [];
+  for (const line of rawEvent.split(/\r?\n/)) {
+    if (!line.startsWith("data:"))
+      continue;
+    dataLines.push(line.slice(5).trimStart());
   }
-  const re2 = /"name"\s*:\s*"advisor"[^}]*?"id"\s*:\s*"(toolu_[A-Za-z0-9_-]+)"/g;
-  while ((m = re2.exec(chunkText)) !== null) {
-    rememberAdvisorToolUseId(m[1]);
+  if (dataLines.length === 0)
+    return false;
+  const payload = dataLines.join(`
+`).trim();
+  if (!payload || payload === "[DONE]")
+    return true;
+  return parseAdvisorIdsFromJsonText(payload, sessionId);
+}
+function parseAdvisorIdsFromJsonText(text, sessionId) {
+  const trimmed = text.trimStart();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+    return false;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return false;
   }
+  collectAdvisorIdsFromValue(parsed, 0, sessionId);
+  return true;
 }
-function rememberAdvisorToolUseId(id) {
-  if (advisorToolUseIds.has(id))
+function collectAdvisorIdsFromValue(value, depth, sessionId) {
+  if (value === null || typeof value !== "object" || depth > MAX_WALK_DEPTH)
+    return;
+  if (Array.isArray(value)) {
+    for (const item of value)
+      collectAdvisorIdsFromValue(item, depth + 1, sessionId);
     return;
-  if (advisorToolUseIds.size >= MAX_TRACKED) {
-    const first = advisorToolUseIds.values().next().value;
-    if (first !== undefined)
-      advisorToolUseIds.delete(first);
   }
-  advisorToolUseIds.add(id);
+  const obj = value;
+  if (obj.type === "tool_use" && obj.name === ADVISOR_TOOL_NAME && typeof obj.id === "string" && obj.id.length > 0) {
+    rememberAdvisorToolUseId(obj.id, sessionId);
+  }
+  for (const nested of Object.values(obj))
+    collectAdvisorIdsFromValue(nested, depth + 1, sessionId);
+}
+function matchAdvisorIdsByRegex(text, sessionId) {
+  for (const re of ADVISOR_ID_PATTERNS) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      rememberAdvisorToolUseId(m[1], sessionId);
+    }
+  }
 }
-function rewriteAdvisorToolResults(payload, getAdviceFor) {
+function rewriteAdvisorToolResults(payload, getAdviceFor, sessionId) {
   const messages = payload.messages;
   if (!Array.isArray(messages))
     return [];
@@ -45097,12 +45230,18 @@ function rewriteAdvisorToolResults(payload, getAdviceFor) {
       const toolUseId = block.tool_use_id;
       if (typeof toolUseId !== "string")
         continue;
-      if (!advisorToolUseIds.has(toolUseId))
+      if (!lookupAdvisorCall(toolUseId, sessionId))
         continue;
-      const advice = getAdviceFor(toolUseId);
-      block.content = [{ type: "text", text: advice }];
-      if (block.is_error)
+      const supplied = getAdviceFor(toolUseId);
+      if (supplied === undefined)
+        continue;
+      const result = typeof supplied === "string" ? { text: supplied, isError: false } : supplied;
+      block.content = [{ type: "text", text: result.text }];
+      if (result.isError) {
+        block.is_error = true;
+      } else if (block.is_error) {
         block.is_error = false;
+      }
       rewritten.push(toolUseId);
     }
   }
@@ -45111,7 +45250,34 @@ function rewriteAdvisorToolResults(payload, getAdviceFor) {
 function stubAdvisorAdvice(toolUseId) {
   return `CLAUDISH_ADVISOR_STUB_${toolUseId}: Evaluation mode \u2014 this advice was supplied by a claudish proxy stub. For the rate-limiter design, consider a hybrid: local token bucket per node for burst tolerance plus a central quota coordinator for cross-region fairness. Use the CAP tradeoff as your framing; expose availability vs accuracy knobs per tenant. The single most important decision is your failure mode: fail-open vs fail-closed.`;
 }
-function findPendingAdvisorToolResults(payload) {
+function prepareLegacyStubResult(cfg, toolUseId, sessionId) {
+  const result = { text: stubAdvisorAdvice(toolUseId), isError: false };
+  markAdvisorCallConsumed(toolUseId, result, sessionId);
+  logAdvisorEvent(cfg, {
+    kind: "advisor_rewrite",
+    event: "advisor_rewrite",
+    toolUseId,
+    sessionId: sessionId ?? null,
+    panel: [],
+    originsByModel: {},
+    failedModels: [],
+    collector: null,
+    collectorOrigin: null,
+    resultOrigin: "stub",
+    stubPath: ADVISOR_STUB_PATHS.LEGACY_STUB,
+    isError: false
+  });
+  return result;
+}
+function missingAdvisorResult(toolUseId) {
+  log(`[advisor] no prepared result for recorded call ${toolUseId} (stub path S2)`);
+  warnAdvisor(`advisor call ${toolUseId}: claudish had no prepared result (internal error)`);
+  return {
+    text: `${ADVISOR_ERROR_PREFIX} claudish recorded advisor call ${toolUseId} but had no result prepared for it (internal error). ${ADVISOR_ERROR_SUFFIX}`,
+    isError: true
+  };
+}
+function findPendingAdvisorToolResults(payload, sessionId) {
   const messages = payload.messages;
   if (!Array.isArray(messages))
     return [];
@@ -45130,13 +45296,101 @@ function findPendingAdvisorToolResults(payload) {
       if (block.type !== "tool_result")
         continue;
       const toolUseId = block.tool_use_id;
-      if (typeof toolUseId === "string" && advisorToolUseIds.has(toolUseId)) {
+      if (typeof toolUseId === "string" && lookupAdvisorCall(toolUseId, sessionId)) {
         found.push(toolUseId);
       }
     }
   }
   return found;
 }
+function toolResultText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  return content.map((b) => b && typeof b.text === "string" ? b.text : "").filter(Boolean).join(`
+`);
+}
+function advisorToolUseIdsInPayload(payload) {
+  const ids = new Set;
+  const messages = payload.messages;
+  if (!Array.isArray(messages))
+    return ids;
+  for (const msg of messages) {
+    if (!msg || typeof msg !== "object")
+      continue;
+    const content = msg.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const block of content) {
+      if (!block || typeof block !== "object")
+        continue;
+      const b = block;
+      if (b.type !== "tool_use" || b.name !== ADVISOR_TOOL_NAME)
+        continue;
+      if (typeof b.id === "string" && b.id.length > 0)
+        ids.add(b.id);
+    }
+  }
+  return ids;
+}
+function reportUnrecordedAdvisorCalls(cfg, payload, sessionId) {
+  const messages = payload.messages;
+  if (!Array.isArray(messages))
+    return [];
+  const advisorIds = advisorToolUseIdsInPayload(payload);
+  if (advisorIds.size === 0)
+    return [];
+  const reported = [];
+  for (const msg of messages) {
+    if (!msg || typeof msg !== "object" || msg.role !== "user")
+      continue;
+    const content = msg.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const block of content) {
+      if (!block || typeof block !== "object" || block.type !== "tool_result")
+        continue;
+      const toolUseId = block.tool_use_id;
+      if (typeof toolUseId !== "string")
+        continue;
+      if (!advisorIds.has(toolUseId))
+        continue;
+      if (!NO_SUCH_ADVISOR_TOOL.test(toolResultText(block.content)))
+        continue;
+      if (lookupAdvisorCall(toolUseId, sessionId))
+        continue;
+      const memo = `${sessionKeyFor(sessionId)}\x00${toolUseId}`;
+      if (reportedUnrecorded.has(memo))
+        continue;
+      if (reportedUnrecorded.size >= MAX_REPORTED_UNRECORDED) {
+        const oldest = reportedUnrecorded.values().next().value;
+        if (oldest !== undefined)
+          reportedUnrecorded.delete(oldest);
+      }
+      reportedUnrecorded.add(memo);
+      reported.push(toolUseId);
+      const panel = cfg.models ?? [];
+      logAdvisorEvent(cfg, {
+        kind: "advisor_rewrite",
+        event: "advisor_rewrite",
+        toolUseId,
+        sessionId: sessionId ?? null,
+        panel,
+        originsByModel: Object.fromEntries(panel.map((m) => [m, "absent"])),
+        failedModels: [],
+        collector: cfg.collector ?? null,
+        collectorOrigin: cfg.collector ? "absent" : null,
+        resultOrigin: "absent",
+        stubPath: ADVISOR_STUB_PATHS.NOT_REWRITTEN,
+        isError: true
+      });
+      log(`[advisor] call ${toolUseId} was never rewritten (stub path S10)`);
+      warnAdvisor(`advisor call ${toolUseId} was not answered: claudish never saw the advisor tool call, so the model got "No such tool available: advisor"`);
+    }
+  }
+  return reported;
+}
 function convertToOpenAIMessages(anthropicMessages) {
   return anthropicMessages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({
     role: m.role,
@@ -45164,168 +45418,598 @@ function extractBlocksAsText(content) {
   }).filter(Boolean).join(`
 `);
 }
-function buildAdvisorRequest(parsed, messages, apiKeys, systemPrompt = ADVISOR_SYSTEM_PROMPT) {
-  const openaiMessages = convertToOpenAIMessages(messages);
-  const provider = parsed.provider;
-  if (provider === "google" || provider === "gemini") {
-    return {
-      url: "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKeys.google ?? ""}`
-      },
-      body: {
-        model: parsed.model,
-        max_tokens: 2048,
-        messages: [{ role: "system", content: systemPrompt }, ...openaiMessages]
-      }
-    };
+function describeAdvisorQuestion(input) {
+  const clip = (s) => s.length > MAX_ADVISOR_QUESTION_CHARS ? `${s.slice(0, MAX_ADVISOR_QUESTION_CHARS)}\u2026` : s || null;
+  if (typeof input === "string")
+    return clip(input.trim());
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return null;
+  const obj = input;
+  for (const field of ADVISOR_QUESTION_FIELDS) {
+    const value = obj[field];
+    if (typeof value === "string" && value.trim().length > 0)
+      return clip(value.trim());
   }
-  if (provider === "openai" || provider === "oai") {
-    return {
-      url: "https://api.openai.com/v1/chat/completions",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${apiKeys.openai ?? ""}`
-      },
-      body: {
-        model: parsed.model,
-        max_tokens: 2048,
-        messages: [{ role: "system", content: systemPrompt }, ...openaiMessages]
+  if (Object.keys(obj).length === 0)
+    return null;
+  try {
+    return clip(JSON.stringify(obj));
+  } catch {
+    return null;
+  }
+}
+function advisorQuestionMessage(question) {
+  const body = question === null ? "The assistant named no explicit question, so its question is the conversation itself: " + "advise it on the decision it now faces, the risks in the approach it has taken, and what " + "it should do next." : `The assistant's question is:
+
+${question}`;
+  return "[claudish] The coding assistant paused the work above and consulted its advisor. " + `You are the advisor.
+
+` + `${body}
+
+` + "Answer that question, using the conversation above as context. The advisor tool is provided " + "by the claudish proxy and has no implementation inside the assistant's harness, so any tool " + "error about it is plumbing: do not treat it as the subject, and do not comment on how the " + "call was made.";
+}
+function prepareAdvisorPanelMessages(messages, toolUseId) {
+  if (!Array.isArray(messages))
+    return [];
+  let question = null;
+  const prepared = messages.map((msg) => {
+    if (!msg || typeof msg !== "object" || !Array.isArray(msg.content))
+      return msg;
+    let changed = false;
+    const content = msg.content.map((block) => {
+      if (!block || typeof block !== "object")
+        return block;
+      if (block.type === "tool_use" && block.name === ADVISOR_TOOL_NAME && block.id === toolUseId) {
+        question ??= describeAdvisorQuestion(block.input);
+        return block;
       }
-    };
+      if (block.type === "tool_result" && block.tool_use_id === toolUseId) {
+        changed = true;
+        return {
+          ...block,
+          content: [{ type: "text", text: ADVISOR_PLUMBING_MARKER }],
+          is_error: false
+        };
+      }
+      return block;
+    });
+    return changed ? { ...msg, content } : msg;
+  });
+  prepared.push({
+    role: "user",
+    content: [{ type: "text", text: advisorQuestionMessage(question) }]
+  });
+  return prepared;
+}
+function routeOf(kind, wireModel) {
+  const url = ADVISOR_ENDPOINTS[kind];
+  return { kind, host: new URL(url).host, url, credential: kind, wireModel };
+}
+function advisorRouteFor(modelSpec, role) {
+  const parsed = parseModelSpec(modelSpec);
+  if (role === "collector" && isAnthropicModel(parsed)) {
+    const model = parsed.model;
+    const tier = anthropicTierAlias(model);
+    if (!tier)
+      return routeOf("anthropic", model);
+    const resolved = findEntryByAlias(model)?.modelId ?? latestAnthropicTierModelId(tier);
+    if (!resolved)
+      return { ...routeOf("anthropic", model), unresolvedAlias: model };
+    return routeOf("anthropic", resolved);
   }
-  const rawModelId = parsed.isExplicitProvider && provider !== "openrouter" ? `${provider}/${parsed.model}` : parsed.model;
-  const modelId = resolveModelNameSync("openrouter", rawModelId) ?? rawModelId;
-  return {
-    url: "https://openrouter.ai/api/v1/chat/completions",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKeys.openrouter ?? ""}`,
-      "HTTP-Referer": "https://claudish.com",
-      "X-Title": "Claudish Advisor"
-    },
-    body: {
-      model: modelId,
-      max_tokens: 2048,
-      messages: [{ role: "system", content: systemPrompt }, ...openaiMessages]
+  const provider = parsed.provider;
+  if (provider === "google" || provider === "gemini")
+    return routeOf("google", parsed.model);
+  if (provider === "openai" || provider === "oai")
+    return routeOf("openai", parsed.model);
+  if (!parsed.isExplicitProvider || provider === "openrouter") {
+    return routeOf("openrouter", openRouterWireModelFor(null, parsed.model));
+  }
+  return routeOf("openrouter", openRouterWireModelFor(provider, parsed.model));
+}
+function openRouterIdOf(entry) {
+  const fromAggregator = entry.aggregators?.find((a) => a.provider === "openrouter")?.externalId;
+  if (fromAggregator)
+    return fromAggregator;
+  return entry.sources["openrouter-api"]?.externalId ?? null;
+}
+function lookupOpenRouterId(name) {
+  const entries = getCatalogEntries();
+  if (!entries)
+    return { kind: "unknown" };
+  const lower = name.toLowerCase();
+  if (name.includes("/")) {
+    const match = entries.find((e) => openRouterIdOf(e)?.toLowerCase() === lower);
+    return { kind: "id", id: match ? openRouterIdOf(match) : name };
+  }
+  const byModelId = entries.find((e) => e.modelId.toLowerCase() === lower);
+  if (byModelId) {
+    const id = openRouterIdOf(byModelId);
+    return id ? { kind: "id", id } : { kind: "not-served" };
+  }
+  const byAlias = entries.find((e) => e.aliases.some((a) => a.toLowerCase() === lower));
+  if (byAlias) {
+    const id = openRouterIdOf(byAlias);
+    return id ? { kind: "id", id } : { kind: "not-served" };
+  }
+  const suffix = `/${lower}`;
+  for (const entry of entries) {
+    const id = openRouterIdOf(entry);
+    if (id && (id.toLowerCase() === lower || id.toLowerCase().endsWith(suffix))) {
+      return { kind: "id", id };
+    }
+  }
+  return { kind: "unknown" };
+}
+function isOpenRouterVendorNamespace(vendor) {
+  const entries = getCatalogEntries();
+  if (!entries)
+    return false;
+  const prefix = `${vendor.toLowerCase()}/`;
+  return entries.some((e) => openRouterIdOf(e)?.toLowerCase().startsWith(prefix));
+}
+function nativeVendorsForProvider(providerUid) {
+  const vendors = new Set;
+  try {
+    for (const plan of readAllModelsCache()?.plans ?? []) {
+      if (plan.routing?.providerUid !== providerUid)
+        continue;
+      for (const native of plan.routing.nativeModelProviders ?? [])
+        vendors.add(native);
     }
+  } catch {}
+  return [...vendors];
+}
+function openRouterWireModelFor(provider, model) {
+  const lookup = lookupOpenRouterId(model);
+  if (provider === null || provider === "openrouter") {
+    if (lookup.kind === "id")
+      return lookup.id;
+    if (lookup.kind === "unknown")
+      return model;
+    throw new Error(`${model} cannot be used as an advisor model: the catalog lists no OpenRouter id for it ` + "(OpenRouter is where every unprefixed advisor model is called), so claudish has no id " + "OpenRouter would accept. Name a model OpenRouter serves, or give the id in full " + '("openrouter@vendor/model").');
+  }
+  const vendorPrefixed = `${provider}/${model}`;
+  if (isOpenRouterVendorNamespace(provider))
+    return vendorPrefixed;
+  if (lookup.kind === "id")
+    return lookup.id;
+  for (const vendor of nativeVendorsForProvider(provider)) {
+    if (isOpenRouterVendorNamespace(vendor))
+      return `${vendor}/${model}`;
+  }
+  if (getCatalogEntries() === null)
+    return vendorPrefixed;
+  throw new Error(`${provider}@${model} cannot be resolved to a model OpenRouter serves: "${provider}" is not an ` + "OpenRouter vendor namespace, and the catalog lists no OpenRouter id for " + `"${model}". Advisor panel models are always called metered, so a subscription prefix ` + `buys nothing here \u2014 use the bare model name ("${model}"), or name the OpenRouter id ` + 'in full ("openrouter@vendor/model").');
+}
+function advisorCredentialsFor(models, collector) {
+  const needed = new Set;
+  const add = (spec, role) => {
+    try {
+      needed.add(advisorRouteFor(spec, role).credential);
+    } catch {}
   };
+  for (const m of models)
+    add(m, "panel");
+  if (collector && models.length > 1)
+    add(collector, "collector");
+  return needed;
 }
-async function callAdvisorModel(modelSpec, messages, apiKeys) {
-  const parsed = parseModelSpec(modelSpec);
-  const { url, headers, body } = buildAdvisorRequest(parsed, messages, apiKeys);
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), 60000);
+function isPlaceholderAnthropicKey(key) {
+  return /placeholder/i.test(key);
+}
+async function resolveAdvisorCredential(credential) {
+  const fromAuthority = async (provider, header) => {
+    try {
+      const auth = await credentials.getRequestAuth(provider, { model: "" });
+      const bearer = auth.headers.Authorization?.replace(/^Bearer\s+/i, "").trim();
+      const apiKey = auth.headers["x-api-key"]?.trim();
+      return (header === "x-api-key" ? apiKey : bearer || apiKey) || undefined;
+    } catch {
+      return;
+    }
+  };
+  if (credential === "anthropic") {
+    const key = await fromAuthority(ADVISOR_AUTHORITY_PROVIDER.anthropic, "x-api-key");
+    if (!key || key === process.env.ANTHROPIC_AUTH_TOKEN || isPlaceholderAnthropicKey(key)) {
+      return;
+    }
+    return key;
+  }
+  if (credential === "google") {
+    return await fromAuthority(ADVISOR_AUTHORITY_PROVIDER.google, "any") || process.env.GOOGLE_API_KEY?.trim() || undefined;
+  }
+  return fromAuthority(ADVISOR_AUTHORITY_PROVIDER[credential], "any");
+}
+function advisorTokenParamFor(route) {
+  if (route.kind !== "openai")
+    return "max_tokens";
+  let fromCatalog;
   try {
-    const resp = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      signal: controller.signal
-    });
-    if (!resp.ok) {
-      const errText = await resp.text().catch(() => "");
-      throw new Error(`${resp.status}: ${errText.slice(0, 200)}`);
+    fromCatalog = lookupModelTokenParam(route.wireModel);
+  } catch {}
+  if (fromCatalog === "max_tokens" || fromCatalog === "max_completion_tokens")
+    return fromCatalog;
+  return "max_completion_tokens";
+}
+function buildAdvisorRequest(route, messages, apiKeys, systemPrompt = ADVISOR_SYSTEM_PROMPT) {
+  if (route.kind === "anthropic") {
+    throw new Error(`${route.wireModel}: the Anthropic route is collector-only`);
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${apiKeys[route.credential] ?? ""}`
+  };
+  if (route.kind === "openrouter") {
+    headers["HTTP-Referer"] = "https://claudish.com";
+    headers["X-Title"] = "Claudish Advisor";
+  }
+  const body = {
+    model: route.wireModel,
+    messages: [{ role: "system", content: systemPrompt }, ...convertToOpenAIMessages(messages)]
+  };
+  body[advisorTokenParamFor(route)] = ADVISOR_MAX_OUTPUT_TOKENS;
+  return { headers, body };
+}
+function stubOutcome(base, stubPath, reason, latencyMs, secrets, observed) {
+  return {
+    ...base,
+    upstreamStatus: observed?.status ?? null,
+    upstreamStatusSource: observed?.source ?? null,
+    responseBytes: observed?.bytes ?? 0,
+    latencyMs,
+    origin: "stub",
+    stubPath,
+    reason: sanitizeAdvisorReason(reason, secrets)
+  };
+}
+function summarizeErrorBody(bodyText) {
+  let message = "";
+  try {
+    message = extractProviderMessage(JSON.parse(bodyText));
+  } catch {
+    message = bodyText;
+  }
+  const oneLine = String(message ?? "").replace(/\s+/g, " ").trim();
+  return oneLine ? oneLine.slice(0, 200) : "(empty body)";
+}
+function describeFetchError(err, timeoutMs) {
+  const e = err;
+  if (e?.name === "AbortError" && timeoutMs) {
+    return `timed out after ${Math.round(timeoutMs / 1000)}s`;
+  }
+  return `request failed: ${e?.message ?? String(err)}`;
+}
+async function executeAdvisorFetch(plan, fetchImpl) {
+  const base = { role: plan.role, requestedModel: plan.requestedModel, route: plan.route };
+  const secrets = credentialValuesInHeaders(plan.headers);
+  const started = performance.now();
+  const elapsed = () => Math.round(performance.now() - started);
+  const controller = plan.timeoutMs ? new AbortController : undefined;
+  const timer = controller ? setTimeout(() => controller.abort(), plan.timeoutMs) : undefined;
+  const doFetch = fetchImpl ?? fetch;
+  try {
+    let resp;
+    try {
+      resp = await doFetch(plan.route.url, {
+        method: "POST",
+        headers: plan.headers,
+        body: JSON.stringify(plan.body),
+        signal: controller?.signal
+      });
+    } catch (err) {
+      return stubOutcome(base, plan.errorStubPath, describeFetchError(err, plan.timeoutMs), elapsed(), secrets);
     }
-    const data = await resp.json();
-    return data.choices?.[0]?.message?.content ?? "(no response)";
+    let bodyText;
+    try {
+      bodyText = await resp.text();
+    } catch (err) {
+      return stubOutcome(base, plan.errorStubPath, `HTTP ${resp.status} but the body could not be read: ${describeFetchError(err, plan.timeoutMs)}`, elapsed(), secrets, { status: resp.status, source: "http_status", bytes: 0 });
+    }
+    const bodyStatus = extractUpstreamStatus(bodyText);
+    const observed = {
+      status: bodyStatus ?? resp.status,
+      source: bodyStatus !== undefined ? "error.upstream_status" : "http_status",
+      bytes: new TextEncoder().encode(bodyText).byteLength
+    };
+    if (!resp.ok || bodyStatus !== undefined && bodyStatus >= 400) {
+      return stubOutcome(base, plan.errorStubPath, `HTTP ${observed.status}: ${summarizeErrorBody(bodyText)}`, elapsed(), secrets, observed);
+    }
+    let data;
+    try {
+      data = JSON.parse(bodyText);
+    } catch {
+      return stubOutcome(base, plan.emptyStubPath, `HTTP ${observed.status} but the response body is not JSON`, elapsed(), secrets, observed);
+    }
+    const text = plan.extractText(data);
+    if (typeof text !== "string" || text.trim().length === 0) {
+      return stubOutcome(base, plan.emptyStubPath, `HTTP ${observed.status} but the response carried no advice text`, elapsed(), secrets, observed);
+    }
+    return {
+      ...base,
+      upstreamStatus: observed.status,
+      upstreamStatusSource: observed.source,
+      responseBytes: observed.bytes,
+      latencyMs: elapsed(),
+      origin: "upstream",
+      stubPath: null,
+      text
+    };
   } finally {
-    clearTimeout(timeout);
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+function extractChatCompletionText(data) {
+  const content = data?.choices?.[0]?.message?.content;
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const joined = content.map((p) => typeof p?.text === "string" ? p.text : "").join("");
+    return joined || undefined;
+  }
+  return;
+}
+function extractAnthropicText(data) {
+  const blocks = data?.content;
+  if (!Array.isArray(blocks))
+    return;
+  const text = blocks.find((b) => b?.type === "text")?.text;
+  return typeof text === "string" ? text : undefined;
+}
+function errorMessageOf(err) {
+  return err?.message ?? String(err);
+}
+async function callAdvisorModel(modelSpec, messages, apiKeys, fetchImpl) {
+  let plan;
+  try {
+    const route = advisorRouteFor(modelSpec, "panel");
+    const { headers, body } = buildAdvisorRequest(route, messages, apiKeys);
+    plan = {
+      role: "panel",
+      requestedModel: modelSpec,
+      route,
+      headers,
+      body,
+      timeoutMs: ADVISOR_PANEL_TIMEOUT_MS,
+      extractText: extractChatCompletionText,
+      emptyStubPath: ADVISOR_STUB_PATHS.PANEL_EMPTY,
+      errorStubPath: ADVISOR_STUB_PATHS.PANEL_ERROR
+    };
+  } catch (err) {
+    const base = { role: "panel", requestedModel: modelSpec, route: null };
+    return stubOutcome(base, ADVISOR_STUB_PATHS.PANEL_ERROR, `could not build the request: ${errorMessageOf(err)}`, 0, credentialValuesOf(apiKeys));
   }
+  return executeAdvisorFetch(plan, fetchImpl);
+}
+function anthropicTierAlias(model) {
+  const m = model.toLowerCase();
+  return m === "opus" || m === "sonnet" || m === "haiku" ? m : null;
 }
 function isAnthropicModel(parsed) {
   const m = parsed.model.toLowerCase();
   return parsed.provider === "anthropic" || m.startsWith("claude-") || m === "haiku" || m === "sonnet" || m === "opus";
 }
-async function callAnthropicCollector(model, adviceText, apiKey) {
-  const aliasResolved = model === "haiku" || model === "sonnet" || model === "opus" ? findEntryByAlias(model)?.modelId : null;
-  const resolvedModel = aliasResolved ?? model;
-  const resp = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
+function planAnthropicCollector(requestedModel, route, adviceText, apiKey) {
+  return {
+    role: "collector",
+    requestedModel,
+    route,
     headers: {
       "Content-Type": "application/json",
       "x-api-key": apiKey ?? "",
       "anthropic-version": "2023-06-01"
     },
-    body: JSON.stringify({
-      model: resolvedModel,
+    body: {
+      model: route.wireModel,
       max_tokens: 1024,
       system: COLLECTOR_SYSTEM_PROMPT,
       messages: [{ role: "user", content: adviceText }]
-    })
-  });
-  if (!resp.ok)
-    throw new Error(`anthropic collector ${resp.status}`);
-  const data = await resp.json();
-  return data.content?.find((b) => b.type === "text")?.text ?? "(empty)";
+    },
+    timeoutMs: ADVISOR_COLLECTOR_TIMEOUT_MS,
+    extractText: extractAnthropicText,
+    emptyStubPath: ADVISOR_STUB_PATHS.ANTHROPIC_COLLECTOR_EMPTY,
+    errorStubPath: ADVISOR_STUB_PATHS.COLLECTOR_FAILED
+  };
 }
-async function callCollectorModel(collectorSpec, advice, apiKeys) {
-  const adviceText = advice.map((a, i) => `### Advisor ${i + 1} (${a.model})
+async function callCollectorModel(collectorSpec, advice, apiKeys, fetchImpl) {
+  let plan;
+  try {
+    const adviceText = advice.map((a, i) => `### Advisor ${i + 1} (${a.model})
 ${a.text}`).join(`
 
 `);
-  const parsed = parseModelSpec(collectorSpec);
-  if (isAnthropicModel(parsed)) {
-    return callAnthropicCollector(parsed.model, adviceText, apiKeys.anthropic);
-  }
-  const collectorMessages = [{ role: "user", content: adviceText }];
-  const { url, headers, body } = buildAdvisorRequest(parsed, collectorMessages, apiKeys, COLLECTOR_SYSTEM_PROMPT);
-  body.messages = [
-    { role: "system", content: COLLECTOR_SYSTEM_PROMPT },
-    { role: "user", content: adviceText }
-  ];
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), 30000);
-  try {
-    const resp = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body),
-      signal: controller.signal
-    });
-    if (!resp.ok)
-      throw new Error(`collector ${resp.status}`);
-    const data = await resp.json();
-    return data.choices?.[0]?.message?.content ?? "(collector returned empty)";
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-async function fetchMultiModelAdvice(_toolUseId, messages, models, collector, apiKeys) {
-  const results = await Promise.allSettled(models.map((model) => callAdvisorModel(model, messages, apiKeys)));
-  const sections = [];
-  const successfulAdvice = [];
-  for (let i = 0;i < models.length; i++) {
-    const result = results[i];
-    if (result.status === "fulfilled") {
-      sections.push(`## ${models[i]}
-${result.value}`);
-      successfulAdvice.push({ model: models[i], text: result.value });
+    const route = advisorRouteFor(collectorSpec, "collector");
+    if (route.unresolvedAlias) {
+      throw new Error(`"${route.unresolvedAlias}" is a claudish alias, not a model id ${route.host} accepts, and ` + "the model catalog holds no id for it, so claudish refused to send it. Name the " + 'collector by its full model id (for example "claude-haiku-4-5"), or refresh the ' + "catalog (`claudish --models-refresh`).");
+    }
+    if (route.kind === "anthropic") {
+      plan = planAnthropicCollector(collectorSpec, route, adviceText, apiKeys.anthropic);
     } else {
-      sections.push(`## ${models[i]}
-[Error: ${result.reason?.message ?? "unknown"}]`);
+      const { headers, body } = buildAdvisorRequest(route, [], apiKeys, COLLECTOR_SYSTEM_PROMPT);
+      body.messages = [
+        { role: "system", content: COLLECTOR_SYSTEM_PROMPT },
+        { role: "user", content: adviceText }
+      ];
+      plan = {
+        role: "collector",
+        requestedModel: collectorSpec,
+        route,
+        headers,
+        body,
+        timeoutMs: ADVISOR_COLLECTOR_TIMEOUT_MS,
+        extractText: extractChatCompletionText,
+        emptyStubPath: ADVISOR_STUB_PATHS.COLLECTOR_EMPTY,
+        errorStubPath: ADVISOR_STUB_PATHS.COLLECTOR_FAILED
+      };
     }
+  } catch (err) {
+    const base = {
+      role: "collector",
+      requestedModel: collectorSpec,
+      route: null
+    };
+    return stubOutcome(base, ADVISOR_STUB_PATHS.COLLECTOR_FAILED, `could not build the request: ${errorMessageOf(err)}`, 0, credentialValuesOf(apiKeys));
   }
-  if (models.length === 1 && successfulAdvice.length === 1) {
-    return successfulAdvice[0].text;
+  return executeAdvisorFetch(plan, fetchImpl);
+}
+function panelFailureSection(o) {
+  return `## ${o.requestedModel}
+[Error: ${o.requestedModel} returned no advice \u2014 ${o.reason}]`;
+}
+function allPanelFailedText(panel) {
+  if (panel.length === 0) {
+    return `${ADVISOR_ERROR_PREFIX} No advisor model is configured, so no advice was produced. ${ADVISOR_ERROR_SUFFIX}`;
   }
-  if (!collector || successfulAdvice.length === 0) {
-    return sections.join(`
+  const head = panel.length === 1 ? `The advisor model ${panel[0].requestedModel} did not return advice.` : `None of the ${panel.length} advisor models returned advice.`;
+  const lines = panel.map((o) => `- ${o.requestedModel}: ${o.reason}`);
+  return `${ADVISOR_ERROR_PREFIX} ${head}
+${lines.join(`
+`)}
+${ADVISOR_ERROR_SUFFIX}`;
+}
+function collectorFailedText(collector, sections) {
+  return `${ADVISOR_ERROR_PREFIX} The collector model ${collector.requestedModel} failed to synthesize ` + `the advice: ${collector.reason}. The panel's unsynthesized answers follow.
 
-`);
-  }
-  try {
-    const synthesized = await callCollectorModel(collector, successfulAdvice, apiKeys);
-    return synthesized;
-  } catch (err) {
-    log(`[advisor] collector ${collector} failed: ${err.message}, falling back to concat`);
-    return sections.join(`
+` + sections.join(`
 
 `);
+}
+function modelCallRecord(kind, outcome, call) {
+  return {
+    kind,
+    event: kind,
+    toolUseId: call.toolUseId,
+    sessionId: call.sessionId,
+    role: outcome.role,
+    requestedModel: outcome.requestedModel,
+    provider: outcome.route?.kind ?? null,
+    route: outcome.route ? { kind: outcome.route.kind, host: outcome.route.host } : null,
+    routedModel: outcome.route?.wireModel ?? null,
+    upstreamStatus: outcome.upstreamStatus,
+    upstreamStatusSource: outcome.upstreamStatusSource,
+    responseBytes: outcome.responseBytes,
+    latencyMs: outcome.latencyMs,
+    origin: outcome.origin,
+    stubPath: outcome.stubPath,
+    reason: outcome.reason ?? null
+  };
+}
+function logAdvisorCallOutcome(cfg, o) {
+  for (const p of o.panel)
+    logAdvisorEvent(cfg, modelCallRecord("advisor_call", p, o));
+  if (o.collectorOutcome) {
+    logAdvisorEvent(cfg, modelCallRecord("advisor_collector_call", o.collectorOutcome, o));
+  }
+  const failedModels = [...o.panel, ...o.collectorOutcome ? [o.collectorOutcome] : []].filter((m) => m.origin !== "upstream").map((m) => m.requestedModel);
+  logAdvisorEvent(cfg, {
+    kind: "advisor_rewrite",
+    event: "advisor_rewrite",
+    toolUseId: o.toolUseId,
+    sessionId: o.sessionId,
+    panel: o.panel.map((p) => p.requestedModel),
+    originsByModel: Object.fromEntries(o.panel.map((p) => [p.requestedModel, p.origin])),
+    failedModels,
+    collector: o.collector,
+    collectorOrigin: o.collectorOutcome ? o.collectorOutcome.origin : o.collector ? "absent" : null,
+    resultOrigin: o.resultOrigin,
+    stubPath: o.stubPath,
+    isError: o.result.isError
+  });
+}
+function warnOnAdvisorFailures(o, warn = warnAdvisor) {
+  const failed = [...o.panel, ...o.collectorOutcome ? [o.collectorOutcome] : []].filter((m) => m.origin !== "upstream");
+  if (failed.length === 0 && o.resultOrigin === "upstream")
+    return;
+  const detail = failed.length > 0 ? failed.map((m) => `${m.role === "collector" ? "collector " : ""}${m.requestedModel}: ${m.reason}`).join("; ") : "no advisor model is configured";
+  const verdict = o.resultOrigin === "upstream" ? "advice from the other models was still delivered" : "the model received an error report instead of advice";
+  warn(`advisor call ${o.toolUseId} \u2014 ${detail} (${verdict})`);
+}
+function recoverUnassociatedAdvisorResult(cfg, outcome, warn = warnAdvisor) {
+  const lost = [
+    ...outcome.panel.map((p) => p.requestedModel),
+    ...outcome.collectorOutcome ? [outcome.collectorOutcome.requestedModel] : []
+  ];
+  const result = {
+    text: `${ADVISOR_ERROR_PREFIX} claudish could not associate the advisor answer with call ` + `${outcome.toolUseId}: its record was gone by the time the answer arrived, so the advice ` + `from ${lost.length > 0 ? lost.join(", ") : "the panel"} could not be delivered. ` + ADVISOR_ERROR_SUFFIX,
+    isError: true
+  };
+  const sessionId = outcome.sessionId ?? undefined;
+  rememberAdvisorToolUseId(outcome.toolUseId, sessionId);
+  markAdvisorCallConsumed(outcome.toolUseId, result, sessionId);
+  log(`[advisor] call ${outcome.toolUseId}: the result could not be associated with the tracked call (stub path ${ADVISOR_STUB_PATHS.PREPARED_RESULT_MISSING})`);
+  if (cfg) {
+    logAdvisorEvent(cfg, {
+      kind: "advisor_rewrite",
+      event: "advisor_rewrite",
+      toolUseId: outcome.toolUseId,
+      sessionId: outcome.sessionId,
+      corrects: "advisor_rewrite",
+      panel: outcome.panel.map((p) => p.requestedModel),
+      originsByModel: Object.fromEntries(outcome.panel.map((p) => [p.requestedModel, "stub"])),
+      failedModels: lost,
+      collector: outcome.collector,
+      collectorOrigin: outcome.collectorOutcome ? "stub" : null,
+      resultOrigin: "stub",
+      stubPath: ADVISOR_STUB_PATHS.PREPARED_RESULT_MISSING,
+      isError: true
+    });
   }
+  warn(`advisor call ${outcome.toolUseId}: the panel answered, but claudish no longer had a record of the call, so the model received an error report instead of the advice`);
+  return result;
+}
+async function runAdvisorCall(params) {
+  const { toolUseId, messages, models, collector, apiKeys, fetchImpl } = params;
+  const panelMessages = prepareAdvisorPanelMessages(messages, toolUseId);
+  const panel = await Promise.all(models.map((m) => callAdvisorModel(m, panelMessages, apiKeys, fetchImpl)));
+  const successful = panel.filter((o) => o.origin === "upstream");
+  const sections = panel.map((o) => o.origin === "upstream" ? `## ${o.requestedModel}
+${o.text}` : panelFailureSection(o));
+  let result;
+  let collectorOutcome = null;
+  let resultOrigin;
+  let stubPath = null;
+  if (models.length === 1 && successful.length === 1) {
+    result = { text: successful[0].text, isError: false };
+    resultOrigin = "upstream";
+  } else if (successful.length === 0) {
+    result = { text: allPanelFailedText(panel), isError: true };
+    resultOrigin = "stub";
+    stubPath = ADVISOR_STUB_PATHS.ALL_PANEL_FAILED;
+  } else if (!collector) {
+    result = { text: sections.join(`
+
+`), isError: false };
+    resultOrigin = "upstream";
+  } else {
+    collectorOutcome = await callCollectorModel(collector, successful.map((o) => ({ model: o.requestedModel, text: o.text })), apiKeys, fetchImpl);
+    if (collectorOutcome.origin === "upstream" && collectorOutcome.text !== undefined) {
+      result = { text: collectorOutcome.text, isError: false };
+      resultOrigin = "upstream";
+    } else {
+      log(`[advisor] collector ${collector} failed: ${collectorOutcome.reason}, falling back to concat`);
+      result = { text: collectorFailedText(collectorOutcome, sections), isError: true };
+      resultOrigin = "stub";
+      stubPath = collectorOutcome.stubPath;
+    }
+  }
+  const outcome = {
+    toolUseId,
+    sessionId: params.sessionId ?? null,
+    panel,
+    collector,
+    collectorOutcome,
+    resultOrigin,
+    stubPath,
+    result
+  };
+  log(`[advisor] call ${toolUseId}: resultOrigin=${resultOrigin}${stubPath ? ` stubPath=${stubPath}` : ""} ` + `origins=${panel.map((p) => `${p.requestedModel}:${p.origin}`).join(",")}` + (collectorOutcome ? ` collector=${collectorOutcome.requestedModel}:${collectorOutcome.origin}` : ""));
+  if (params.cfg)
+    logAdvisorCallOutcome(params.cfg, outcome);
+  warnOnAdvisorFailures(outcome, params.warn);
+  return outcome;
 }
-var ADVISOR_SERVER_TOOL_TYPE = "advisor_20260301", ADVISOR_BETA_FLAG = "advisor-tool-2026-03-01", advisorToolUseIds, MAX_TRACKED = 256, ADVISOR_SYSTEM_PROMPT = `You are a strategic advisor to a coding agent. You have been given the full conversation history between a user and a Claude Code coding assistant. The assistant has paused to consult you for guidance.
+var ADVISOR_SERVER_TOOL_TYPE = "advisor_20260301", ADVISOR_BETA_FLAG = "advisor-tool-2026-03-01", ADVISOR_ORIGIN_LOG_PREFIX = "[advisor-origin]", ORIGIN_RECORD_KINDS, REDACTED = "[redacted]", MIN_REDACTABLE_SECRET_LENGTH = 8, ADVISOR_STUB_PATHS, ADVISOR_ERROR_PREFIX = "[claudish advisor error]", ADVISOR_ERROR_SUFFIX = "This tool result is an error report from the claudish proxy, not advice.", NO_SESSION_BUCKET = "__no_session__", ADVISOR_PENDING_LIMITS, SWEEP_INTERVAL_MS = 60000, pendingBySession, clock, lastSweepAt, ADVISOR_TOOL_NAME = "advisor", MAX_WALK_DEPTH = 32, MAX_SSE_BUFFER_CHARS, inFlightByToolUseId, inFlightAdvisorCalls, MAX_IN_FLIGHT_ADVISOR_CALLS, streamFrameBuffer, ADVISOR_ID_PATTERNS, NO_SUCH_ADVISOR_TOOL, reportedUnrecorded, MAX_REPORTED_UNRECORDED = 1024, ADVISOR_PLUMBING_MARKER = "(handled by the claudish proxy \u2014 this advisor call is what you are being asked to answer; there is no local tool output)", ADVISOR_QUESTION_FIELDS, MAX_ADVISOR_QUESTION_CHARS = 4000, ADVISOR_SYSTEM_PROMPT = `You are a strategic advisor to a coding agent. You have been given the full conversation history between a user and a Claude Code coding assistant. The assistant has paused to consult you for guidance.
 
 Review the conversation and provide concise, actionable advice. Focus on:
 - Architectural decisions and trade-offs
@@ -45337,13 +46021,523 @@ Be direct. Limit your response to 300-500 words.`, COLLECTOR_SYSTEM_PROMPT = `Yo
 - Identifies consensus points (where advisors agree)
 - Highlights disagreements and explains which perspective is stronger
 - Produces a clear, actionable recommendation
-Be concise. Do not attribute advice to specific models.`;
+Be concise. Do not attribute advice to specific models.`, ADVISOR_ENDPOINTS, ADVISOR_AUTHORITY_PROVIDER, ADVISOR_MAX_OUTPUT_TOKENS = 2048, ADVISOR_PANEL_TIMEOUT_MS = 60000, ADVISOR_COLLECTOR_TIMEOUT_MS = 30000;
 var init_native_handler_advisor = __esm(() => {
+  init_model_catalog();
+  init_authority();
   init_logger();
+  init_all_models_cache();
   init_catalog_client();
   init_catalog_query();
   init_model_parser();
-  advisorToolUseIds = new Set;
+  init_anthropic_error();
+  ORIGIN_RECORD_KINDS = new Set([
+    "advisor_call",
+    "advisor_collector_call",
+    "advisor_rewrite"
+  ]);
+  ADVISOR_STUB_PATHS = Object.freeze({
+    LEGACY_STUB: "S1",
+    PREPARED_RESULT_MISSING: "S2",
+    DISABLED_STUB: "S3",
+    PANEL_EMPTY: "S4",
+    ANTHROPIC_COLLECTOR_EMPTY: "S5",
+    COLLECTOR_EMPTY: "S6",
+    PANEL_ERROR: "S7",
+    ALL_PANEL_FAILED: "S8",
+    COLLECTOR_FAILED: "S9",
+    NOT_REWRITTEN: "S10"
+  });
+  ADVISOR_PENDING_LIMITS = Object.freeze({
+    maxCallsPerSession: 256,
+    maxSessions: 64,
+    ttlMs: 24 * 60 * 60 * 1000
+  });
+  pendingBySession = new Map;
+  clock = Date.now;
+  lastSweepAt = Number.NEGATIVE_INFINITY;
+  MAX_SSE_BUFFER_CHARS = 256 * 1024;
+  inFlightByToolUseId = new Map;
+  inFlightAdvisorCalls = new Map;
+  MAX_IN_FLIGHT_ADVISOR_CALLS = ADVISOR_PENDING_LIMITS.maxSessions * ADVISOR_PENDING_LIMITS.maxCallsPerSession;
+  streamFrameBuffer = new SseFrameBuffer;
+  ADVISOR_ID_PATTERNS = [
+    /"type"\s*:\s*"tool_use"[^}]*?"id"\s*:\s*"([^"]+)"[^}]*?"name"\s*:\s*"advisor"/g,
+    /"name"\s*:\s*"advisor"[^}]*?"id"\s*:\s*"([^"]+)"/g,
+    /"id"\s*:\s*"([^"]+)"\s*,\s*"name"\s*:\s*"advisor"/g
+  ];
+  NO_SUCH_ADVISOR_TOOL = /No such tool available:\s*advisor\b/;
+  reportedUnrecorded = new Set;
+  ADVISOR_QUESTION_FIELDS = [
+    "question",
+    "prompt",
+    "query",
+    "request",
+    "task",
+    "topic",
+    "context",
+    "input",
+    "text"
+  ];
+  ADVISOR_ENDPOINTS = Object.freeze({
+    google: "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+    openai: "https://api.openai.com/v1/chat/completions",
+    openrouter: "https://openrouter.ai/api/v1/chat/completions",
+    anthropic: "https://api.anthropic.com/v1/messages"
+  });
+  ADVISOR_AUTHORITY_PROVIDER = Object.freeze({
+    google: "google",
+    openai: "openai",
+    openrouter: "openrouter",
+    anthropic: "native-anthropic"
+  });
+});
+
+// src/handlers/advisor-decorator.ts
+async function resolveAdvisorKeys(needed, inboundApiKey) {
+  const anthropicKey = async () => {
+    if (inboundApiKey && !isPlaceholderAnthropicKey(inboundApiKey))
+      return inboundApiKey;
+    return resolveAdvisorCredential("anthropic");
+  };
+  const [openrouter, google, openai, anthropic] = await Promise.all([
+    needed.has("openrouter") ? resolveAdvisorCredential("openrouter") : undefined,
+    needed.has("google") ? resolveAdvisorCredential("google") : undefined,
+    needed.has("openai") ? resolveAdvisorCredential("openai") : undefined,
+    needed.has("anthropic") ? anthropicKey() : undefined
+  ]);
+  return { openrouter, google, openai, anthropic };
+}
+function toolsOfferAdvisor(tools) {
+  if (!Array.isArray(tools))
+    return false;
+  return tools.some((t) => {
+    if (!t || typeof t !== "object")
+      return false;
+    const tool = t;
+    return tool.type === ADVISOR_SERVER_TOOL_TYPE2 || tool.name === ADVISOR_TOOL_NAME2;
+  });
+}
+function createAdvisorPresenceMonitor(warn = logStderr) {
+  let consecutiveAbsent = 0;
+  let warned = false;
+  return {
+    observe(payload) {
+      if (warned)
+        return;
+      const tools = payload?.tools;
+      if (!Array.isArray(tools) || tools.length === 0)
+        return;
+      if (toolsOfferAdvisor(tools)) {
+        consecutiveAbsent = 0;
+        return;
+      }
+      consecutiveAbsent++;
+      log(`[advisor-swap] request offers ${tools.length} tool(s) but no advisor (${consecutiveAbsent} in a row)`);
+      if (consecutiveAbsent < ADVISOR_ABSENT_WARN_AFTER)
+        return;
+      warned = true;
+      warn(`[advisor] Claude Code sent ${consecutiveAbsent} requests in a row that offer tools but no advisor tool, so --advisor is having no effect. Claude Code is not offering the advisor in this session (for example, the experimental advisor flag was withdrawn or disabled). This warning is shown once.`);
+    }
+  };
+}
+function withAdvisorSwap(inner, cfg, deps = {}) {
+  if (!cfg.enabled)
+    return inner;
+  if (inner instanceof AdvisorSwapHandler)
+    return inner;
+  return new AdvisorSwapHandler(inner, cfg, deps);
+}
+
+class AdvisorSwapHandler {
+  inner;
+  cfg;
+  deps;
+  constructor(inner, cfg, deps = {}) {
+    this.inner = inner;
+    this.cfg = cfg;
+    this.deps = deps;
+  }
+  async handle(c, payload) {
+    if (c.get("advisorHandled") === true)
+      return this.inner.handle(c, payload);
+    c.set("advisorHandled", true);
+    const sessionId = extractSessionId(payload);
+    try {
+      this.deps.presence?.observe(payload);
+    } catch {}
+    await applyAdvisorRequestSide(c, payload, this.cfg, sessionId, this.deps.resolveKeys ?? resolveAdvisorKeys);
+    const response = await this.inner.handle(c, payload);
+    return tapAdvisorResponse(response, this.cfg, sessionId);
+  }
+  async shutdown() {
+    await this.inner.shutdown();
+  }
+}
+async function applyAdvisorRequestSide(c, payload, cfg, sessionId, resolveKeys) {
+  const target = payload.model;
+  const sessionLabel = sessionId ?? NO_SESSION_BUCKET;
+  const swapped = swapAdvisorToolInBody(payload);
+  if (swapped) {
+    c.set(ADVISOR_SWAPPED_CONTEXT_KEY, true);
+    log(`[advisor-swap] replaced advisor_20260301 with function tool 'advisor' (model=${target}, session=${sessionLabel})`);
+    logAdvisorEvent(cfg, {
+      kind: "swap_applied",
+      model: target,
+      originalTool: swapped.originalTool,
+      regularTool: swapped.regularTool
+    });
+  }
+  const cachedResult = (id) => getAdvisorCall(id, sessionId)?.result;
+  let rewrittenIds = [];
+  if (cfg.models && cfg.models.length > 0) {
+    const models = cfg.models;
+    rewriteAdvisorToolResults(payload, cachedResult, sessionId);
+    const pendingIds = findPendingAdvisorToolResults(payload, sessionId);
+    if (pendingIds.length > 0) {
+      const freshIds = [];
+      const delivered = new Map;
+      let apiKeys;
+      for (const id of pendingIds) {
+        if (cachedResult(id))
+          continue;
+        const runPanel = async () => {
+          apiKeys ??= await resolveKeys(advisorCredentialsFor(models, cfg.collector), c.req.header("x-api-key"));
+          const outcome = await runAdvisorCall({
+            toolUseId: id,
+            sessionId,
+            messages: payload.messages,
+            models,
+            collector: cfg.collector ?? null,
+            apiKeys,
+            cfg
+          });
+          if (!markAdvisorCallConsumed(id, outcome.result, sessionId)) {
+            return recoverUnassociatedAdvisorResult(cfg, outcome);
+          }
+          return outcome.result;
+        };
+        let { promise, joined } = joinOrStartAdvisorCall(id, sessionId, runPanel);
+        if (joined) {
+          log(`[advisor-swap] advisor call ${id} is already running for this session; joined it instead of running the panel again (session=${sessionLabel})`);
+          try {
+            delivered.set(id, await promise);
+            continue;
+          } catch (err) {
+            log(`[advisor-swap] the in-flight advisor call ${id} failed (${errorMessage(err)}); running our own`);
+            ({ promise, joined } = joinOrStartAdvisorCall(id, sessionId, runPanel));
+          }
+        }
+        delivered.set(id, await promise);
+        if (!joined)
+          freshIds.push(id);
+      }
+      rewrittenIds = rewriteAdvisorToolResults(payload, (id) => cachedResult(id) ?? delivered.get(id) ?? missingAdvisorResult(id), sessionId);
+      if (rewrittenIds.length > 0) {
+        const replayed = rewrittenIds.filter((id) => !freshIds.includes(id));
+        log(`[advisor-swap] rewrote ${rewrittenIds.length} advisor tool_result(s) (session=${sessionLabel}) fresh=[${freshIds.join(", ")}] replayed=[${replayed.join(", ")}] panel=[${cfg.models.join(", ")}] collector=${cfg.collector ?? "none"}`);
+        logAdvisorEvent(cfg, {
+          kind: "multi_model_rewrite",
+          ids: rewrittenIds,
+          freshIds,
+          models: cfg.models,
+          collector: cfg.collector,
+          model: target
+        });
+      }
+    }
+  } else {
+    for (const id of findPendingAdvisorToolResults(payload, sessionId)) {
+      if (!cachedResult(id))
+        prepareLegacyStubResult(cfg, id, sessionId);
+    }
+    rewrittenIds = rewriteAdvisorToolResults(payload, (id) => cachedResult(id) ?? stubAdvisorAdvice(id), sessionId);
+    if (rewrittenIds.length > 0) {
+      log(`[advisor-swap] rewrote ${rewrittenIds.length} advisor tool_result(s) with stub advice (session=${sessionLabel}): ${rewrittenIds.join(", ")}`);
+      logAdvisorEvent(cfg, {
+        kind: "tool_result_rewritten",
+        ids: rewrittenIds,
+        model: target
+      });
+    }
+  }
+  reportUnrecordedAdvisorCalls(cfg, payload, sessionId);
+  if (cfg.dumpBodies) {
+    logAdvisorEvent(cfg, {
+      kind: "request_body",
+      swapApplied: !!swapped,
+      rewrittenIds,
+      model: target,
+      body: trimForLog(payload)
+    });
+  }
+}
+function tapAdvisorResponse(response, cfg, sessionId) {
+  const body = response.body;
+  if (!body)
+    return response;
+  const contentType = response.headers.get("content-type") ?? "";
+  const kind = contentType.includes("text/event-stream") ? "sse" : contentType.includes("json") ? "json" : null;
+  if (!kind)
+    return response;
+  let toClient;
+  let toScan;
+  try {
+    [toClient, toScan] = body.tee();
+  } catch (err) {
+    log(`[advisor-swap] response not scanned (${errorMessage(err)}); passed through untouched`);
+    return response;
+  }
+  const clientReader = toClient.getReader();
+  const scanReader = toScan.getReader();
+  drainScanBranch(scanReader, kind, cfg, sessionId);
+  const passthrough = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await clientReader.read();
+        if (done)
+          controller.close();
+        else
+          controller.enqueue(value);
+      } catch (err) {
+        controller.error(err);
+      }
+    },
+    cancel(reason) {
+      scanReader.cancel(reason).catch(() => {});
+      return clientReader.cancel(reason);
+    }
+  }, { highWaterMark: 0 });
+  return new Response(passthrough, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+async function drainScanBranch(reader, kind, cfg, sessionId) {
+  const decoder = new TextDecoder;
+  const scanner = kind === "sse" ? createAdvisorStreamScanner(cfg, sessionId) : null;
+  let jsonText = "";
+  let jsonTooLarge = false;
+  const take = (text) => {
+    if (!text)
+      return;
+    if (scanner) {
+      scanner.push(text);
+    } else if (!jsonTooLarge) {
+      jsonText += text;
+      if (jsonText.length > MAX_JSON_SCAN_CHARS) {
+        jsonTooLarge = true;
+        jsonText = "";
+      }
+    }
+  };
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      take(typeof value === "string" ? value : decoder.decode(value, { stream: true }));
+    }
+    take(decoder.decode());
+    if (jsonTooLarge) {
+      log(`[advisor-swap] non-stream response over ${MAX_JSON_SCAN_CHARS} chars was not scanned for advisor calls`);
+    } else if (!scanner && jsonText.trim()) {
+      recordAdvisorEventsFromResponseBody(cfg, JSON.parse(jsonText), sessionId);
+    }
+  } catch (err) {
+    log(`[advisor-swap] response scan stopped: ${errorMessage(err)} (client stream unaffected)`);
+    reader.cancel(err).catch(() => {});
+  }
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function trimForLog(payload) {
+  const TEXT_TRUNC = 400;
+  const clone = structuredClone(payload);
+  const trimStr = (s) => typeof s === "string" && s.length > TEXT_TRUNC ? `${s.slice(0, TEXT_TRUNC)}\u2026 [+${s.length - TEXT_TRUNC} chars]` : s;
+  const walk = (v) => {
+    if (typeof v === "string")
+      return trimStr(v);
+    if (Array.isArray(v))
+      return v.map(walk);
+    if (v && typeof v === "object") {
+      const out = {};
+      for (const [k, val] of Object.entries(v))
+        out[k] = walk(val);
+      return out;
+    }
+    return v;
+  };
+  return walk(clone);
+}
+var ADVISOR_SWAPPED_CONTEXT_KEY = "advisorSwapped", ADVISOR_SERVER_TOOL_TYPE2 = "advisor_20260301", ADVISOR_TOOL_NAME2 = "advisor", MAX_JSON_SCAN_CHARS, ADVISOR_ABSENT_WARN_AFTER = 3;
+var init_advisor_decorator = __esm(() => {
+  init_harness();
+  init_logger();
+  init_native_handler_advisor();
+  MAX_JSON_SCAN_CHARS = 16 * 1024 * 1024;
+});
+
+// src/handlers/fallback-handler.ts
+class FallbackHandler {
+  candidates;
+  lastSuccessIndex = 0;
+  constructor(candidates) {
+    this.candidates = candidates;
+  }
+  async handle(c, payload) {
+    const errors = [];
+    const startIndex = this.lastSuccessIndex;
+    for (let attempt = 0;attempt < this.candidates.length; attempt++) {
+      const idx = (startIndex + attempt) % this.candidates.length;
+      const { name, handler } = this.candidates[idx];
+      const isLast = attempt === this.candidates.length - 1;
+      try {
+        if (errors.length > 0 && handler instanceof ComposedHandler) {
+          try {
+            handler.setFallbackMeta(this.candidates.map((c) => c.name), errors.length);
+          } catch {}
+        }
+        const response = await handler.handle(c, payload);
+        if (response.ok) {
+          this.lastSuccessIndex = idx;
+          if (errors.length > 0) {
+            logStderr(`[Fallback] ${name} succeeded after ${errors.length} failed attempt(s)`);
+            if (handler instanceof ComposedHandler) {
+              handler.getTokenTracker()?.setProviderDisplayName(name);
+            }
+          }
+          return response;
+        }
+        const errorBody = await response.clone().text();
+        if (!isRetryableError(response.status, errorBody, name)) {
+          if (errors.length > 0) {
+            errors.push({ provider: name, status: response.status, message: errorBody });
+            return this.formatCombinedError(c, errors, payload.model);
+          }
+          return response;
+        }
+        errors.push({ provider: name, status: response.status, message: errorBody });
+        if (!isLast) {
+          if (hasQuotaExhaustionWording(errorBody)) {
+            logStderr(`[Fallback] ${name} subscription allowance is spent \u2014 falling through to the next provider, which is billed PER TOKEN. Use a provider prefix (e.g. \`zgo@model\`) to fail instead of switching.`);
+          } else {
+            logStderr(`[Fallback] ${name} failed (HTTP ${response.status}), trying next provider...`);
+          }
+        }
+      } catch (err) {
+        errors.push({ provider: name, status: 0, message: err.message });
+        if (!isLast) {
+          logStderr(`[Fallback] ${name} error: ${err.message}, trying next provider...`);
+        }
+      }
+    }
+    return this.formatCombinedError(c, errors, payload.model);
+  }
+  formatCombinedError(c, errors, modelName) {
+    const summary = errors.map((e) => `  ${e.provider}: HTTP ${e.status || "ERR"} \u2014 ${truncate(parseErrorMessage(e.message), 150)}`).join(`
+`);
+    logStderr(`[Fallback] All ${errors.length} provider(s) failed for ${modelName || "model"}:
+${summary}`);
+    return c.json({
+      error: {
+        type: "all_providers_failed",
+        message: `All ${errors.length} providers failed for model '${modelName || "unknown"}'`,
+        attempts: errors.map((e) => ({
+          provider: e.provider,
+          status: e.status,
+          error: truncate(parseErrorMessage(e.message), 200)
+        }))
+      }
+    }, exhaustedChainStatus(errors));
+  }
+  async shutdown() {
+    for (const { handler } of this.candidates) {
+      if (typeof handler.shutdown === "function") {
+        await handler.shutdown();
+      }
+    }
+  }
+}
+function isRetryableError(status, errorBody, provider) {
+  if (hasQuotaExhaustionWording(errorBody))
+    return true;
+  const upstream = status === 400 ? extractUpstreamStatus(errorBody) : undefined;
+  if (upstream === 401 || upstream === 403 || upstream === 402 || upstream === 429) {
+    return true;
+  }
+  if (status === 401 || status === 403)
+    return true;
+  if (status === 402)
+    return true;
+  if (status === 404)
+    return true;
+  if (status === 429)
+    return true;
+  const lower = errorBody.toLowerCase();
+  if (status === 422) {
+    if (lower.includes("not available") || lower.includes("model not found") || lower.includes("not supported")) {
+      return true;
+    }
+  }
+  if (status === 400) {
+    if (lower.includes("model not found") || lower.includes("not registered") || lower.includes("does not exist") || lower.includes("unknown model") || lower.includes("unsupported model") || lower.includes("no healthy deployment") || lower.includes("requires a google cloud project") || lower.includes("unsupported_client")) {
+      return true;
+    }
+    if (provider?.toLowerCase().includes("antigravity") && lower.includes("invalid argument")) {
+      return true;
+    }
+    if (isProvider(provider, "opencodezen") && (lower.includes("upstream request failed") || lower.includes("error from provider ("))) {
+      return true;
+    }
+  }
+  if (status === 500) {
+    if (lower.includes("insufficient balance") || lower.includes("insufficient credit") || lower.includes("quota exceeded") || lower.includes("billing")) {
+      return true;
+    }
+  }
+  return false;
+}
+function exhaustedChainStatus(errors) {
+  if (errors.length === 0)
+    return 400;
+  const isTransient = (e) => {
+    if (e.status === 429 || e.status === 503)
+      return true;
+    if (hasQuotaExhaustionWording(e.message))
+      return true;
+    const upstream = e.status === 400 ? extractUpstreamStatus(e.message) : undefined;
+    return upstream === 429 || upstream === 503;
+  };
+  return errors.every(isTransient) ? 503 : 400;
+}
+function isProvider(provider, needle) {
+  if (!provider)
+    return false;
+  return provider.toLowerCase().replace(/[^a-z0-9]/g, "").includes(needle);
+}
+function parseErrorMessage(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed.error === "string")
+      return parsed.error;
+    if (typeof parsed.error?.message === "string")
+      return parsed.error.message;
+    if (typeof parsed.message === "string")
+      return parsed.message;
+  } catch {}
+  return body;
+}
+function truncate(s, max) {
+  return s.length > max ? `${s.slice(0, max)}...` : s;
+}
+var init_fallback_handler = __esm(() => {
+  init_logger();
+  init_composed_handler();
+  init_anthropic_error();
+  init_quota_exhaustion();
 });
 
 // src/handlers/shared/thinking-signature.ts
@@ -45375,36 +46569,6 @@ function stripUnsignedThinkingBlocks(messages) {
 }
 
 // src/handlers/native-handler.ts
-async function resolveAdvisorKeys() {
-  const keyFromAuthority = async (name) => {
-    try {
-      const auth = await credentials.getRequestAuth(name, { model: "" });
-      const k = auth.headers.Authorization?.replace(/^Bearer\s+/i, "") || auth.headers["x-api-key"];
-      return k || undefined;
-    } catch {
-      return;
-    }
-  };
-  const geminiKey = async () => {
-    const local = process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || getApiKey("GEMINI_API_KEY");
-    if (local)
-      return local;
-    if (hasOpSources()) {
-      const r = await resolveOpKeyForEnvVars(new Set(["GEMINI_API_KEY", "GOOGLE_API_KEY"]), {
-        onAuthFailure: "skip"
-      });
-      return r.GEMINI_API_KEY || r.GOOGLE_API_KEY || undefined;
-    }
-    return;
-  };
-  const [openrouter, google, openai] = await Promise.all([
-    keyFromAuthority("openrouter"),
-    geminiKey(),
-    keyFromAuthority("openai")
-  ]);
-  return { openrouter, google, openai };
-}
-
 class NativeHandler {
   apiKey;
   baseUrl;
@@ -45423,65 +46587,7 @@ class NativeHandler {
     if (strippedThinking > 0) {
       log(`[Native] stripped ${strippedThinking} unsigned thinking block(s) from history for ${target} (foreign-provider origin)`);
     }
-    const advisorCfg = loadAdvisorSwapConfig(this.advisorModels, this.advisorCollector);
-    let advisorSwapped = null;
-    let advisorRewrittenIds = [];
-    if (advisorCfg.enabled) {
-      advisorSwapped = swapAdvisorToolInBody(payload);
-      if (advisorSwapped) {
-        log("[Native][advisor-swap] replaced advisor_20260301 with regular tool 'advisor'");
-        logAdvisorEvent(advisorCfg, {
-          kind: "swap_applied",
-          model: target,
-          originalTool: advisorSwapped.originalTool,
-          regularTool: advisorSwapped.regularTool
-        });
-      }
-      if (advisorCfg.models && advisorCfg.models.length > 0) {
-        const pendingIds = findPendingAdvisorToolResults(payload);
-        if (pendingIds.length > 0) {
-          const adviceMap = new Map;
-          for (const id of pendingIds) {
-            const advisorKeys = await resolveAdvisorKeys();
-            const advice = await fetchMultiModelAdvice(id, payload.messages, advisorCfg.models, advisorCfg.collector ?? null, {
-              ...advisorKeys,
-              anthropic: originalHeaders["x-api-key"]
-            });
-            adviceMap.set(id, advice);
-          }
-          advisorRewrittenIds = rewriteAdvisorToolResults(payload, (id) => adviceMap.get(id) ?? stubAdvisorAdvice(id));
-          if (advisorRewrittenIds.length > 0) {
-            log(`[Native][advisor] rewrote ${advisorRewrittenIds.length} tool_result(s) with multi-model advice from [${advisorCfg.models.join(", ")}]${advisorCfg.collector ? ` (collector: ${advisorCfg.collector})` : " (no collector)"}`);
-            logAdvisorEvent(advisorCfg, {
-              kind: "multi_model_rewrite",
-              ids: advisorRewrittenIds,
-              models: advisorCfg.models,
-              collector: advisorCfg.collector,
-              model: target
-            });
-          }
-        }
-      } else {
-        advisorRewrittenIds = rewriteAdvisorToolResults(payload, stubAdvisorAdvice);
-        if (advisorRewrittenIds.length > 0) {
-          log(`[Native][advisor-swap] rewrote ${advisorRewrittenIds.length} error tool_result(s) with stub advice: ${advisorRewrittenIds.join(", ")}`);
-          logAdvisorEvent(advisorCfg, {
-            kind: "tool_result_rewritten",
-            ids: advisorRewrittenIds,
-            model: target
-          });
-        }
-      }
-      if (advisorCfg.dumpBodies) {
-        logAdvisorEvent(advisorCfg, {
-          kind: "request_body",
-          swapApplied: !!advisorSwapped,
-          rewrittenIds: advisorRewrittenIds,
-          model: target,
-          body: trimForLog(payload)
-        });
-      }
-    }
+    const advisorSwapped = c.get(ADVISOR_SWAPPED_CONTEXT_KEY) === true;
     log(`
 === [NATIVE] Claude Code \u2192 Anthropic API Request ===`);
     log(`[Native] x-api-key: ${originalHeaders["x-api-key"] ? maskCredential(originalHeaders["x-api-key"]) : "(not set)"}`);
@@ -45515,7 +46621,7 @@ class NativeHandler {
         const { stripped, changed } = stripAdvisorBeta(incomingBeta);
         if (changed) {
           log(`[Native][advisor-swap] stripped advisor-tool beta; before=${incomingBeta} after=${stripped ?? "(empty)"}`);
-          logAdvisorEvent(advisorCfg, {
+          logAdvisorEvent(loadAdvisorSwapConfig(this.advisorModels, this.advisorCollector), {
             kind: "beta_stripped",
             before: incomingBeta,
             after: stripped ?? ""
@@ -45552,7 +46658,6 @@ class NativeHandler {
                 controller.enqueue(value);
                 const chunkText = decoder.decode(value, { stream: true });
                 buffer += chunkText;
-                recordAdvisorEventsFromChunk(advisorCfg, chunkText);
                 const lines = buffer.split(`
 `);
                 buffer = lines.pop() || "";
@@ -45582,11 +46687,6 @@ class NativeHandler {
       log(`
 === [NATIVE] Response ===`);
       log(JSON.stringify(data, null, 2));
-      if (advisorCfg.enabled) {
-        try {
-          recordAdvisorEventsFromChunk(advisorCfg, JSON.stringify(data));
-        } catch {}
-      }
       const responseHeaders = { "Content-Type": "application/json" };
       if (anthropicResponse.headers.has("anthropic-version")) {
         responseHeaders["anthropic-version"] = anthropicResponse.headers.get("anthropic-version");
@@ -45599,30 +46699,10 @@ class NativeHandler {
   }
   async shutdown() {}
 }
-function trimForLog(payload) {
-  const TEXT_TRUNC = 400;
-  const clone = structuredClone(payload);
-  const trimStr = (s) => typeof s === "string" && s.length > TEXT_TRUNC ? `${s.slice(0, TEXT_TRUNC)}\u2026 [+${s.length - TEXT_TRUNC} chars]` : s;
-  const walk = (v) => {
-    if (typeof v === "string")
-      return trimStr(v);
-    if (Array.isArray(v))
-      return v.map(walk);
-    if (v && typeof v === "object") {
-      const out = {};
-      for (const [k, val] of Object.entries(v))
-        out[k] = walk(val);
-      return out;
-    }
-    return v;
-  };
-  return walk(clone);
-}
 var init_native_handler = __esm(() => {
   init_authority();
-  init_op_source();
   init_logger();
-  init_profile_config();
+  init_advisor_decorator();
   init_native_handler_advisor();
   init_anthropic_error();
 });
@@ -46463,6 +47543,10 @@ 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 advisorPresence = createAdvisorPresenceMonitor();
+  const withAdvisor = (handler, presence) => withAdvisorSwap(handler, loadAdvisorSwapConfig(options.advisorModels, options.advisorCollector), {
+    presence
+  });
   const requestShapingOpts = {
     effortOverride: isEffortLevel(options.effortOverride) ? options.effortOverride : undefined,
     modelParams: options.modelParams,
@@ -46872,9 +47956,9 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
       if (!monitorMode && options.classifier?.enabled && isAutoModeClassifierRequest(body)) {
         log(`[Classifier] auto-mode permission classifier \u2192 native Anthropic (model ${body.model} \u2192 ${options.classifier.model})`);
         rewriteClassifierForNative(body, options.classifier.model);
-        return nativeHandler.handle(c, body);
+        return await withAdvisor(nativeHandler).handle(c, body);
       }
-      const handler = await getHandlerForRequest(body.model);
+      const handler = withAdvisor(await getHandlerForRequest(body.model), advisorPresence);
       return await handler.handle(c, body);
     } catch (e) {
       log(`[Proxy] Error: ${e}`);
@@ -46930,8 +48014,10 @@ var init_proxy_server = __esm(() => {
   init_authority();
   init_hooks();
   init_behavior();
+  init_advisor_decorator();
   init_composed_handler();
   init_fallback_handler();
+  init_native_handler_advisor();
   init_native_handler();
   init_anthropic_error();
   init_logger();
@@ -56287,7 +57373,11 @@ function parseAdvisorFlag(value) {
   } else {
     collector = collectorPart;
   }
-  return { models, collector };
+  return {
+    models,
+    collector,
+    collectorDefaulted: models.length > 1 && collectorPart === undefined
+  };
 }
 async function parseArgs(args) {
   const config = {
@@ -56435,7 +57525,8 @@ async function parseArgs(args) {
       const parsed = parseAdvisorFlag(modelsArg);
       config.advisorModels = parsed.models;
       config.advisorCollector = parsed.collector;
-      config.monitor = true;
+      config.advisorCollectorDefaulted = parsed.collectorDefaulted;
+      config.advisor = true;
     } else if (arg === "--stdin") {
       config.stdin = true;
     } else if (arg === "--free") {
@@ -56669,10 +57760,10 @@ Usage:  claudish --models --provider <slug>`);
   if (config._sawVerbose && !config.interactive && !config.claudeArgs.includes("--verbose") && !config.claudeArgs.includes("-v")) {
     config.claudeArgs.push("--verbose");
   }
+  if ((config.monitor || config.advisor) && process.env.ANTHROPIC_API_KEY?.includes("placeholder")) {
+    delete process.env.ANTHROPIC_API_KEY;
+  }
   if (config.monitor) {
-    if (process.env.ANTHROPIC_API_KEY?.includes("placeholder")) {
-      delete process.env.ANTHROPIC_API_KEY;
-    }
     if (!config.quiet) {
       console.log("[claudish] Monitor mode enabled - proxying to real Anthropic API");
       console.log("[claudish] Using Claude Code's native authentication");
@@ -57639,7 +58730,7 @@ ${h("OPTIONS")}
   ${green("--stdin")}                  Read prompt from stdin (large prompts / piping)
   ${green("--free")}                   Show only FREE models in the interactive selector
   ${green("--monitor")}                Monitor mode - proxy to REAL Anthropic API and log traffic
-  ${green("--advisor")} ${yellow('"m1,m2[:collector]"')}  Multi-model advisor replacement (implies --monitor)
+  ${green("--advisor")} ${yellow('"m1,m2[:collector]"')}  Multi-model advisor replacement (works with any --model)
   ${green("--model-params")} ${yellow('"k=v,..."')}  Extra request params merged into the payload (e.g. reasoning.mode=pro)
   ${green("--effort-override")} ${yellow("<level>")}  Pin reasoning effort verbatim, skipping the per-model clamp
   ${green("--pro-on-ultracode")}       Apply the model's catalog preset while in ultracode (opt-in)
@@ -65601,12 +66692,34 @@ function shouldHideIncidentalAnthropicKey(config, env = process.env) {
     return false;
   return !wantsAnthropicApiBilling(config, env);
 }
+function scrubInheritedClaudishPlaceholders(env) {
+  const removed = [];
+  for (const name of ["ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_API_KEY"]) {
+    if (isClaudishPlaceholderCredential(name, env[name])) {
+      delete env[name];
+      removed.push(name);
+    }
+  }
+  return { removed };
+}
+function isClaudishPlaceholderCredential(name, value) {
+  if (name === "ANTHROPIC_API_KEY")
+    return value === CLAUDISH_PLACEHOLDER_API_KEY;
+  if (name === "ANTHROPIC_AUTH_TOKEN")
+    return value === CLAUDISH_PLACEHOLDER_AUTH_TOKEN;
+  return false;
+}
+function isRealAnthropicEnvCredential(env, name) {
+  const value = env[name];
+  return Boolean(value) && !isClaudishPlaceholderCredential(name, value);
+}
 function hasResolvableAnthropicAuth(deps = {}) {
   const env = deps.env ?? process.env;
   const fileExists = deps.fileExists ?? existsSync31;
   const keychainProbe = deps.keychainProbe ?? defaultKeychainAnthropicProbe;
-  if (env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN)
+  if (isRealAnthropicEnvCredential(env, "ANTHROPIC_API_KEY") || isRealAnthropicEnvCredential(env, "ANTHROPIC_AUTH_TOKEN")) {
     return true;
+  }
   if (fileExists(join41(homedir36(), ".claude", ".credentials.json")))
     return true;
   return keychainProbe();
@@ -65614,8 +66727,11 @@ function hasResolvableAnthropicAuth(deps = {}) {
 function shouldPreserveNativeAuth(config) {
   return hasNativeAnthropicMapping(config) || classifierPassthroughEnabled(config) && hasResolvableAnthropicAuth();
 }
+function isAdvisorNativeSession(config) {
+  return Boolean(config.advisor) && !config.model && !config.modelChain;
+}
 function isProxyAuthMode(config) {
-  return !config.monitor && !shouldPreserveNativeAuth(config);
+  return !config.monitor && !isAdvisorNativeSession(config) && !shouldPreserveNativeAuth(config);
 }
 function managedSettingsPath() {
   if (isWindows2()) {
@@ -66012,9 +67128,48 @@ function resolveContextWindowEnv(realWindow, processEnv = process.env) {
     notice: `[claudish] Model's real context window (${realWindow.toLocaleString()}) is below ` + `Claude Code's ${MIN_AUTO_COMPACT_WINDOW.toLocaleString()}-token auto-compact floor \u2014 ` + "leaving CLAUDE_CODE_AUTO_COMPACT_WINDOW unset so native auto-compaction stays on."
   };
 }
+function resolveAdvisorToolEnv(config, processEnv = process.env) {
+  if (!config.advisor)
+    return { vars: {}, source: "off" };
+  if (processEnv[ADVISOR_TOOL_ENV_VAR] !== undefined)
+    return { vars: {}, source: "inherited" };
+  return { vars: { [ADVISOR_TOOL_ENV_VAR]: "1" }, source: "claudish" };
+}
+function discoverUserAdvisorModel(claudeArgs = [], cwd = process.cwd()) {
+  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync31(file));
+  const idx = claudeArgs.indexOf("--settings");
+  const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
+  if (settingsArg)
+    sources.push(settingsArg);
+  const managed = managedSettingsPath();
+  if (existsSync31(managed))
+    sources.push(managed);
+  let effective;
+  for (const source of sources) {
+    const layer = parseSettingsArgSafe(source);
+    if (!layer || !("advisorModel" in layer))
+      continue;
+    const value = layer.advisorModel;
+    effective = typeof value === "string" && value !== "" ? value : undefined;
+  }
+  return effective;
+}
+function resolveAdvisorModelArg(config, cwd = process.cwd()) {
+  if (!config.advisor)
+    return { args: [], source: "off" };
+  const userChoice = discoverUserAdvisorModel(config.claudeArgs, cwd);
+  if (userChoice)
+    return { args: [], model: userChoice, source: "inherited" };
+  return {
+    args: ["--advisor", CLAUDISH_CHILD_ADVISOR_MODEL],
+    model: CLAUDISH_CHILD_ADVISOR_MODEL,
+    source: "claudish"
+  };
+}
 async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
   const hasProfileMappings = config.modelOpus || config.modelSonnet || config.modelHaiku || config.modelSubagent;
-  const modelId = config.model || (hasProfileMappings || config.monitor ? undefined : "unknown");
+  const advisorNativeSession = isAdvisorNativeSession(config);
+  const modelId = config.model || (hasProfileMappings || config.monitor || advisorNativeSession ? undefined : "unknown");
   const portMatch = proxyUrl.match(/:(\d+)/);
   const port = portMatch ? portMatch[1] : "unknown";
   const proxyAuthMode = isProxyAuthMode(config);
@@ -66026,6 +67181,7 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
     return 1;
   }
   const userStatusLineCommand = discoverUserStatusLineCommand(config.claudeArgs);
+  const advisorModelArg = resolveAdvisorModelArg(config);
   const {
     path: tempSettingsPath,
     statusLine,
@@ -66034,6 +67190,7 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
   mergeUserSettingsIfPresent(config, tempSettingsPath, statusLine, proxyAuthMode);
   const claudeArgs = [];
   claudeArgs.push("--settings", tempSettingsPath);
+  claudeArgs.push(...advisorModelArg.args);
   if (config.interactive) {
     if (config.autoApprove) {
       claudeArgs.push("--dangerously-skip-permissions");
@@ -66059,12 +67216,14 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
   }
   const isLocalModel = modelId ? modelId.startsWith("ollama/") || modelId.startsWith("ollama:") || modelId.startsWith("lmstudio/") || modelId.startsWith("lmstudio:") || modelId.startsWith("vllm/") || modelId.startsWith("vllm:") || modelId.startsWith("mlx/") || modelId.startsWith("mlx:") || modelId.startsWith("http://") || modelId.startsWith("https://") : false;
   const modelDisplayName = modelId || config.profile || "default";
+  const advisorToolEnv = resolveAdvisorToolEnv(config);
   const env = {
     ...process.env,
     ANTHROPIC_BASE_URL: proxyUrl,
     [ENV.CLAUDISH_ACTIVE_MODEL_NAME]: modelDisplayName,
     CLAUDISH_IS_LOCAL: isLocalModel ? "true" : "false",
-    [ENV.CLAUDISH_TOKEN_FILE]: tokenFilePath
+    [ENV.CLAUDISH_TOKEN_FILE]: tokenFilePath,
+    ...advisorToolEnv.vars
   };
   if (modelId) {
     const parsedSpec = parseModelSpec(modelId);
@@ -66073,9 +67232,15 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
       env[ENV.CLAUDISH_PROVIDER_NAME] = providerDisplayName;
     }
   }
+  if (advisorToolEnv.source !== "off") {
+    log(`[claude-runner] ${ADVISOR_TOOL_ENV_VAR}=${env[ADVISOR_TOOL_ENV_VAR]} (${advisorToolEnv.source})`);
+  }
+  if (advisorModelArg.source !== "off") {
+    log(`[claude-runner] child advisor model=${advisorModelArg.model} (${advisorModelArg.source}` + `${advisorModelArg.source === "inherited" ? "; user setting kept, no --advisor passed" : " via --advisor"})`);
+  }
   let hidAnthropicApiKey = false;
   delete env.CLAUDECODE;
-  if (config.monitor) {
+  if (config.monitor || advisorNativeSession) {
     delete env.ANTHROPIC_API_KEY;
     delete env.ANTHROPIC_AUTH_TOKEN;
     if (modelId) {
@@ -66088,7 +67253,11 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
       env[ENV.ANTHROPIC_SMALL_FAST_MODEL] = modelId;
     }
     if (shouldPreserveNativeAuth(config)) {
-      if (shouldHideIncidentalAnthropicKey(config)) {
+      const scrubbed = scrubInheritedClaudishPlaceholders(env);
+      if (scrubbed.removed.length > 0) {
+        log(`[claude-runner] Removed inherited claudish placeholder credentials: ${scrubbed.removed.join(", ")}`);
+      }
+      if (shouldHideIncidentalAnthropicKey(config, env)) {
         delete env.ANTHROPIC_API_KEY;
         hidAnthropicApiKey = true;
       }
@@ -66096,8 +67265,8 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
       if (classifierPassthroughEnabled(config)) {
         console.error("[claudish] classifier passthrough enabled but no Anthropic credentials detected \u2014 " + "classifier requests will fail to authenticate against api.anthropic.com. " + "Map a role to a native Claude model (e.g. --model-sonnet claude-sonnet-5) or set ANTHROPIC_API_KEY.");
       }
-      env.ANTHROPIC_API_KEY = "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx";
-      env.ANTHROPIC_AUTH_TOKEN = "placeholder-token-not-used-proxy-handles-auth";
+      env.ANTHROPIC_API_KEY = CLAUDISH_PLACEHOLDER_API_KEY;
+      env.ANTHROPIC_AUTH_TOKEN = CLAUDISH_PLACEHOLDER_AUTH_TOKEN;
       const realWindow = await computeMainThreadContextWindow(config);
       const contextEnv = resolveContextWindowEnv(realWindow, process.env);
       Object.assign(env, contextEnv.vars);
@@ -66311,7 +67480,7 @@ var restoreTerminal = null, macosKeychainAnthropicResult, defaultKeychainAnthrop
     macosKeychainAnthropicResult = false;
   }
   return macosKeychainAnthropicResult;
-}, STALE_TOKEN_FILE_MS, MAX_TOKEN_FILES_SCANNED = 4000, CLAUDE_CODE_DEFAULT_MAX_CONTEXT = 200000, USER_STATUS_LINE_TIMEOUT_SECONDS = 3, MIN_AUTO_COMPACT_WINDOW = 200000, SIGNAL_EXIT_NUMBERS;
+}, CLAUDISH_PLACEHOLDER_API_KEY = "sk-ant-api03-placeholder-not-used-proxy-handles-auth-with-openrouter-key-xxxxxxxxxxxxxxxxxxxxx", CLAUDISH_PLACEHOLDER_AUTH_TOKEN = "placeholder-token-not-used-proxy-handles-auth", STALE_TOKEN_FILE_MS, MAX_TOKEN_FILES_SCANNED = 4000, CLAUDE_CODE_DEFAULT_MAX_CONTEXT = 200000, USER_STATUS_LINE_TIMEOUT_SECONDS = 3, MIN_AUTO_COMPACT_WINDOW = 200000, ADVISOR_TOOL_ENV_VAR = "CLAUDE_CODE_ENABLE_EXPERIMENTAL_ADVISOR_TOOL", CLAUDISH_CHILD_ADVISOR_MODEL = "sonnet", SIGNAL_EXIT_NUMBERS;
 var init_claude_runner = __esm(() => {
   init_model_catalog();
   init_config2();
@@ -66596,6 +67765,226 @@ var init_catalog_warm = __esm(() => {
   ];
 });
 
+// src/advisor-startup.ts
+function isClaudeCodeBoolTrue(value) {
+  if (value === undefined)
+    return false;
+  const v = value.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes" || v === "on";
+}
+function routeAdvisorModel(modelSpec, role) {
+  return advisorRouteFor(modelSpec, role);
+}
+function advisorCredentialEnvName(credential) {
+  if (credential === "anthropic")
+    return "ANTHROPIC_API_KEY";
+  return getProviderByName(ADVISOR_AUTHORITY_PROVIDER[credential])?.apiKeyEnvVar || `a ${credential} API key`;
+}
+function alsoAcceptedEnvName(credential) {
+  return credential === "google" ? "GOOGLE_API_KEY" : null;
+}
+async function resolveAdvisorCredentials(needed) {
+  const present = async (credential) => Boolean(await resolveAdvisorCredential(credential));
+  const list = [...needed];
+  const results = await Promise.all(list.map(present));
+  const out = {};
+  list.forEach((c, i) => {
+    out[c] = results[i];
+  });
+  return out;
+}
+function advisorModelStatus(model, route, presence) {
+  const credentialName = advisorCredentialEnvName(route.credential);
+  if (route.unresolvedAlias) {
+    return {
+      model,
+      route,
+      callable: false,
+      credentialName,
+      unresolved: `${model} is a claudish alias, not a model id ${route.host} accepts, and the model ` + "catalog holds no id for it (it is cold or has never been fetched), so claudish would " + `have to POST "${route.unresolvedAlias}" verbatim`
+    };
+  }
+  return {
+    model,
+    route,
+    callable: presence[route.credential] === true,
+    credentialName
+  };
+}
+function describeMissingCredential2(s) {
+  const also = alsoAcceptedEnvName(s.route.credential);
+  return `${s.model} calls ${s.route.host} and needs ${s.credentialName}${also ? ` (or ${also})` : ""}; ` + "none found in env, config, keychain or 1Password";
+}
+function describeUncallable(s) {
+  return s.unresolved ?? describeMissingCredential2(s);
+}
+function formatCarriesTools(format) {
+  try {
+    const out = format.convertTools({
+      tools: [
+        {
+          name: "advisor",
+          description: "startup probe",
+          input_schema: { type: "object", properties: {}, additionalProperties: false }
+        }
+      ]
+    }, false);
+    return Array.isArray(out) && out.length > 0;
+  } catch {
+    return true;
+  }
+}
+function pinnedFormatForTransport(transport, modelName) {
+  switch (transport) {
+    case "ollamacloud":
+      return new OllamaAPIFormat(modelName);
+    default:
+      return null;
+  }
+}
+function resolveMainModelFact(model) {
+  const native = nativeRouteFor(model);
+  if (native)
+    return { model, providerName: native.displayName, carriesTools: true };
+  const resolution = resolveModelProvider(model);
+  const definitionName = resolution.catalogName === "gemini" ? "google" : resolution.catalogName;
+  const definition = definitionName ? getProviderByName(definitionName) : undefined;
+  const format = definition ? pinnedFormatForTransport(definition.transport, resolution.modelName) : null;
+  const providerName = resolution.category === "unknown" ? "unresolved (routed on the first request)" : definition?.displayName || resolution.providerName;
+  return {
+    model,
+    providerName,
+    carriesTools: format ? formatCarriesTools(format) : true,
+    wireFormat: format?.getName()
+  };
+}
+function mainModelSpecs(config) {
+  if (config.modelChain && config.modelChain.length > 0)
+    return [...config.modelChain];
+  if (config.model)
+    return [config.model];
+  const tiers = [config.modelOpus, config.modelSonnet, config.modelHaiku, config.modelSubagent];
+  return [...new Set(tiers.filter((m) => typeof m === "string" && m.length > 0))];
+}
+function modelIdentity(spec) {
+  const model = parseModelSpec(spec).model.toLowerCase();
+  const slash = model.lastIndexOf("/");
+  return slash >= 0 ? model.slice(slash + 1) : model;
+}
+function panelMembersMatchingMain(panel, mainModels) {
+  const main = new Set(mainModels.map(modelIdentity));
+  return panel.filter((p) => main.has(modelIdentity(p)));
+}
+function refusalBeforeCredentials(facts) {
+  const disable = facts.childEnv[ADVISOR_DISABLE_ENV_VAR];
+  if (isClaudeCodeBoolTrue(disable)) {
+    return `${ADVISOR_DISABLE_ENV_VAR}=${JSON.stringify(disable)} is set in your environment. ` + `Claude Code then never offers the advisor tool, and ${ADVISOR_TOOL_ENV_VAR} does not ` + `override it. Unset ${ADVISOR_DISABLE_ENV_VAR} to use --advisor.`;
+  }
+  const toolless = facts.mainModels.filter((m) => !m.carriesTools);
+  if (toolless.length > 0) {
+    const named = toolless.map((m) => `${m.model} (${m.providerName}${m.wireFormat ? `, ${m.wireFormat}` : ""})`).join(", ");
+    return `the main model path cannot carry tools: ${named} drops every tool from the request, ` + "so the advisor tool can never reach the model. Choose a main model on a provider " + "that supports tool calls, or drop --advisor.";
+  }
+  if (facts.panel.length === 0) {
+    return 'no advisor panel models were given. Use --advisor "model1[,model2][:collector]".';
+  }
+  return null;
+}
+function describeRoute(s) {
+  return `${s.model} -> ${s.route.host} (${s.credentialName}, billed per token)`;
+}
+function decideAdvisorStartup(facts) {
+  const early = refusalBeforeCredentials(facts);
+  if (early)
+    return { kind: "refuse", reason: early };
+  const missingPanel = facts.panelStatus.filter((s) => !s.callable);
+  if (missingPanel.length > 0) {
+    return {
+      kind: "refuse",
+      reason: `advisor panel model${missingPanel.length > 1 ? "s" : ""} cannot be called: ` + `${missingPanel.map(describeUncallable).join("; ")}. ` + "Set the key, or remove the model from --advisor."
+    };
+  }
+  let effectiveCollector = facts.collector;
+  let collectorLine = "none";
+  const cs = facts.collectorStatus;
+  if (cs && !cs.callable) {
+    if (!facts.collectorDefaulted) {
+      return {
+        kind: "refuse",
+        reason: `collector ${describeUncallable(cs)}. ` + 'Set the key, name another collector ("a,b:collector"), or end the value with ":" for no collector.'
+      };
+    }
+    effectiveCollector = null;
+    collectorLine = cs.unresolved ? `none \u2014 ${cs.unresolved}; panel answers will be concatenated` : `none \u2014 the default collector ${cs.model} needs ${cs.credentialName}, which was not ` + "found; panel answers will be concatenated";
+  } else if (cs) {
+    collectorLine = describeRoute(cs);
+  }
+  const notice = ["[claudish] --advisor is on for this launch"];
+  notice.push("  panel (panel calls never use a subscription):");
+  for (const s of facts.panelStatus)
+    notice.push(`    ${describeRoute(s)}`);
+  notice.push(`  collector:  ${collectorLine}`);
+  const main = facts.mainModels.length === 0 ? "your Claude Code session" : facts.mainModels.map((m) => `${m.model} via ${m.providerName}`).join(" -> ");
+  notice.push(`  main model: ${main}`);
+  const envValue = facts.childEnv[ADVISOR_TOOL_ENV_VAR];
+  if (facts.toolEnv.source === "inherited") {
+    notice.push(`  ${ADVISOR_TOOL_ENV_VAR}=${JSON.stringify(envValue ?? "")} inherited from your environment` + (isClaudeCodeBoolTrue(envValue) ? "" : " \u2014 Claude Code reads this value as FALSE, so the advisor tool appears only if your main model qualifies for it without the override"));
+  } else {
+    notice.push(`  ${ADVISOR_TOOL_ENV_VAR}=1 set by claudish`);
+  }
+  const includesMain = panelMembersMatchingMain(facts.panel, facts.mainModels.map((m) => m.model));
+  if (includesMain.length > 0) {
+    notice.push(`  note: the panel includes the main model (${includesMain.join(", ")})`);
+  }
+  notice.push("  cost: each advisor call sends the FULL conversation to every panel model, uncached; " + "cost grows with panel size and transcript length");
+  return { kind: "proceed", notice, effectiveCollector };
+}
+async function evaluateAdvisorStartup(config, toolEnv, childEnv = process.env, deps = { resolveCredentials: resolveAdvisorCredentials }) {
+  if (!config.advisor)
+    return null;
+  const panel = config.advisorModels ?? [];
+  const collector = config.advisorCollector ?? null;
+  const mainModels = mainModelSpecs(config).map(resolveMainModelFact);
+  const early = refusalBeforeCredentials({ childEnv, mainModels, panel });
+  if (early)
+    return { kind: "refuse", reason: early };
+  let panelRoutes;
+  let collectorRoute;
+  try {
+    panelRoutes = panel.map((m) => routeAdvisorModel(m, "panel"));
+    collectorRoute = collector ? routeAdvisorModel(collector, "collector") : null;
+  } catch (err) {
+    return {
+      kind: "refuse",
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const needed = new Set(panelRoutes.map((r) => r.credential));
+  if (collectorRoute)
+    needed.add(collectorRoute.credential);
+  const presence = await deps.resolveCredentials(needed);
+  return decideAdvisorStartup({
+    panel,
+    collector,
+    collectorDefaulted: config.advisorCollectorDefaulted === true,
+    mainModels,
+    childEnv,
+    toolEnv,
+    panelStatus: panel.map((m, i) => advisorModelStatus(m, panelRoutes[i], presence)),
+    collectorStatus: collector && collectorRoute ? advisorModelStatus(collector, collectorRoute, presence) : null
+  });
+}
+var ADVISOR_DISABLE_ENV_VAR = "CLAUDE_CODE_DISABLE_ADVISOR_TOOL";
+var init_advisor_startup = __esm(() => {
+  init_ollama_api_format();
+  init_claude_runner();
+  init_native_handler_advisor();
+  init_model_parser();
+  init_native_route();
+  init_provider_definitions();
+  init_provider_resolver();
+});
+
 // src/tui/viz/text.ts
 function columns(n, fn, arg = "width") {
   if (!Number.isFinite(n))
@@ -69482,11 +70871,12 @@ Team Status`);
       process.exit(1);
     }
     const hasProfileTiers = cliConfig.modelOpus || cliConfig.modelSonnet || cliConfig.modelHaiku || cliConfig.modelSubagent;
-    if (cliConfig.interactive && !cliConfig.monitor && !cliConfig.model && !hasProfileTiers) {
+    const advisorNativeSession = isAdvisorNativeSession(cliConfig);
+    if (cliConfig.interactive && !cliConfig.monitor && !advisorNativeSession && !cliConfig.model && !hasProfileTiers) {
       cliConfig.model = await traceSpan("startup:model-select", () => selectModel({ freeOnly: cliConfig.freeOnly }).catch(handlePromptExit), { mayIncludeUserPrompt: true });
       console.log("");
     }
-    if (!cliConfig.interactive && !cliConfig.monitor && !cliConfig.model && !hasProfileTiers) {
+    if (!cliConfig.interactive && !cliConfig.monitor && !advisorNativeSession && !cliConfig.model && !hasProfileTiers) {
       console.error("Error: Model must be specified in non-interactive mode");
       console.error("Use --model <model> flag, set CLAUDISH_MODEL env var, or use --profile");
       console.error("Try: claudish --models");
@@ -69546,16 +70936,36 @@ Team Status`);
         }
       }
     }
+    const warmOutcome = await traceSpan("startup:catalog-warm", () => warmCatalogIfNeeded(cliConfig));
+    if (warmOutcome === "hard_fail") {
+      process.exit(1);
+    }
+    if (cliConfig.advisor) {
+      await Promise.resolve().then(() => init_advisor_startup());
+      const decision = await traceSpan("startup:advisor-check", () => evaluateAdvisorStartup(cliConfig, resolveAdvisorToolEnv(cliConfig)));
+      if (decision?.kind === "refuse") {
+        process.stderr.write(`[claudish] Error: --advisor cannot work in this launch: ${decision.reason}
+`);
+        process.exit(1);
+      }
+      if (decision?.kind === "proceed") {
+        cliConfig.advisorCollector = decision.effectiveCollector;
+        await Promise.resolve().then(() => init_catalog_client());
+        if (getCatalogEntries() === null) {
+          const panel = cliConfig.advisorModels ?? [];
+          decision.notice.push(`  WARNING: the model catalog is not loaded (catalog warm: ${warmOutcome}), so claudish could not verify that ${panel.length === 1 ? "this panel model is" : "these panel models are"} routable: ${panel.join(", ")}. An unroutable one fails on its first advisor call instead of being refused here. Run \`claudish --models-refresh\` to check them at launch.`);
+        }
+        process.stderr.write(`${decision.notice.join(`
+`)}
+`);
+      }
+    }
     if (cliConfig.stdin) {
       const stdinInput = await traceSpan("startup:stdin-read", () => readStdin());
       if (stdinInput.trim()) {
         cliConfig.claudeArgs = [stdinInput, ...cliConfig.claudeArgs];
       }
     }
-    const warmOutcome = await traceSpan("startup:catalog-warm", () => warmCatalogIfNeeded(cliConfig));
-    if (warmOutcome === "hard_fail") {
-      process.exit(1);
-    }
     const port = cliConfig.port || await traceSpan("startup:find-port", () => findAvailablePort(DEFAULT_PORT_RANGE.start, DEFAULT_PORT_RANGE.end));
     const explicitModel = typeof cliConfig.model === "string" ? cliConfig.model : undefined;
     const modelMap = {