claudish 10.1.1 → 10.2.0

package/dist/index.js

@@ -715,7 +715,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "10.1.1";
+var VERSION = "10.2.0";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -802,7 +802,7 @@ function redactDeep(val, key) {
   return val;
 }
 function isStructuralLogWorthy(msg) {
-  return msg.startsWith("[SSE:") || msg.startsWith("[Suppressed]") || msg.startsWith("[Proxy]") || msg.startsWith("[Claude Code]") || msg.startsWith("[Fallback]") || msg.startsWith("[Streaming] ===") || msg.startsWith("[Streaming] Chunk:") || msg.startsWith("[Streaming] Received") || msg.startsWith("[Streaming] Text-based tool calls") || msg.startsWith("[Streaming] Final usage") || msg.startsWith("[Streaming] Sending") || msg.startsWith("[AnthropicSSE] Stream complete") || msg.startsWith("[AnthropicSSE] Tool use:") || msg.includes("Response status:") || msg.includes("Error") || msg.includes("error") || msg.includes("[Auto-route]");
+  return msg.startsWith("[SSE:") || msg.startsWith("[Suppressed]") || msg.startsWith("[Proxy]") || msg.startsWith("[Claude Code]") || msg.startsWith("[Fallback]") || msg.startsWith("[Recovery]") || msg.startsWith("[Streaming] ===") || msg.startsWith("[Streaming] Chunk:") || msg.startsWith("[Streaming] Received") || msg.startsWith("[Streaming] Text-based tool calls") || msg.startsWith("[Streaming] Final usage") || msg.startsWith("[Streaming] Sending") || msg.startsWith("[AnthropicSSE] Stream complete") || msg.startsWith("[AnthropicSSE] Tool use:") || msg.includes("Response status:") || msg.includes("Error") || msg.includes("error") || msg.includes("[Auto-route]");
 }
 function redactLogLine(message, timestamp) {
   if (message.startsWith("[SSE:")) {
@@ -885,6 +885,9 @@ function logStderr(message) {
   }
   log(message);
 }
+function logRecovery(message) {
+  logStderr(message);
+}
 function setDiagOutput(output) {
   diagOutput = output;
 }
@@ -18769,6 +18772,12 @@ function loadConfig() {
     if (config.proOnUltracode !== undefined) {
       merged.proOnUltracode = config.proOnUltracode;
     }
+    if (config.recovery !== undefined) {
+      merged.recovery = config.recovery;
+    }
+    if (config.recoveryUi !== undefined) {
+      merged.recoveryUi = config.recoveryUi;
+    }
     return merged;
   } catch (error) {
     console.error(`Warning: Failed to load config, using defaults: ${error}`);
@@ -18817,6 +18826,26 @@ function readProOnUltracode(paths = defaultScopedConfigPaths) {
   }
   return;
 }
+function readNestedEnabled(key, paths) {
+  for (const pathFn of [paths.project, paths.global]) {
+    try {
+      const path = pathFn();
+      if (!existsSync6(path))
+        continue;
+      const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+      const value = parsed?.[key]?.enabled;
+      if (typeof value === "boolean")
+        return value;
+    } catch {}
+  }
+  return;
+}
+function readRecoveryEnabled(paths = defaultScopedConfigPaths) {
+  return readNestedEnabled("recovery", paths);
+}
+function readRecoveryUi(paths = defaultScopedConfigPaths) {
+  return readNestedEnabled("recoveryUi", paths);
+}
 function isProjectDirectory() {
   const cwd = process.cwd();
   return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync6(join8(cwd, f)));
@@ -24926,6 +24955,749 @@ Signed in to Grok. Try it with: claudish --model gk@grok-4.6 "hello"
   };
 });
 
+// src/handlers/shared/connection-error.ts
+function markOwnTimeout(error) {
+  if (error && typeof error === "object") {
+    try {
+      Object.defineProperty(error, OWN_TIMEOUT_FLAG, {
+        value: true,
+        enumerable: false,
+        configurable: true,
+        writable: true
+      });
+    } catch {}
+  }
+  return error;
+}
+function isOwnTimeout(error) {
+  return Boolean(error?.[OWN_TIMEOUT_FLAG]);
+}
+function findConnectionCode(error) {
+  let e = error;
+  const seen = new Set;
+  for (let depth = 0;e && typeof e === "object" && depth < 8 && !seen.has(e); depth++) {
+    seen.add(e);
+    if (typeof e.code === "string" && e.code in CODE_KIND)
+      return e.code;
+    if (typeof e.name === "string" && e.name in NAME_KIND && isOwnTimeout(e))
+      return e.name;
+    e = e.cause;
+  }
+  const msg = String(error?.message ?? error ?? "");
+  if (/getaddrinfo|ENOTFOUND|EAI_AGAIN|nodename nor servname/i.test(msg))
+    return "ENOTFOUND";
+  if (BUN_CONNECT_MESSAGE.test(msg))
+    return "ConnectionRefused";
+  return null;
+}
+function isLoopback(endpoint) {
+  try {
+    const { hostname } = new URL(endpoint);
+    return /^(localhost|127\.\d+\.\d+\.\d+|0\.0\.0\.0|\[?::1\]?)$/i.test(hostname);
+  } catch {
+    return false;
+  }
+}
+function classifyConnectionError(error) {
+  const code = findConnectionCode(error);
+  if (!code)
+    return null;
+  return { kind: CODE_KIND[code] ?? NAME_KIND[code] ?? "unreachable", code };
+}
+function hostOf(endpoint) {
+  try {
+    return new URL(endpoint).host || endpoint;
+  } catch {
+    return endpoint;
+  }
+}
+function buildConnectionErrorMessage(kind, displayName, endpoint) {
+  const host = hostOf(endpoint);
+  switch (kind) {
+    case "dns":
+      return `Cannot resolve ${host} for ${displayName}. This is a DNS/network problem on your machine \u2014 check your internet connection, VPN, or DNS resolver (e.g. Tailscale MagicDNS) \u2014 not ${displayName}.`;
+    case "refused":
+      if (isLoopback(endpoint)) {
+        return `Cannot connect to ${displayName} at ${endpoint}. Make sure the server is running.`;
+      }
+      return `Cannot reach ${host} for ${displayName}. This is a network problem on your machine \u2014 check your internet connection, VPN, or DNS resolver (e.g. Tailscale MagicDNS) \u2014 not ${displayName}.`;
+    case "unreachable":
+      return `Cannot reach ${displayName} at ${endpoint}. Check your network connection.`;
+  }
+}
+function formatHoldDuration(ms) {
+  const total = Math.max(0, Math.round(ms / 1000));
+  const minutes = Math.floor(total / 60);
+  const seconds = total % 60;
+  return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+function buildRecoveryHoldMessage(reason, attempts, elapsedMs) {
+  return `${reason} claudish retried ${attempts}\xD7 over ${formatHoldDuration(elapsedMs)} ` + "without reaching it \u2014 still trying, watch the recovery pane.";
+}
+var CODE_KIND, BUN_CONNECT_MESSAGE, NAME_KIND, OWN_TIMEOUT_FLAG = "claudishOwnTimeout";
+var init_connection_error = __esm(() => {
+  CODE_KIND = {
+    ENOTFOUND: "dns",
+    EAI_AGAIN: "dns",
+    ECONNREFUSED: "refused",
+    ETIMEDOUT: "unreachable",
+    ECONNRESET: "unreachable",
+    ENETUNREACH: "unreachable",
+    EHOSTUNREACH: "unreachable",
+    EPIPE: "unreachable",
+    UND_ERR_CONNECT_TIMEOUT: "unreachable",
+    UND_ERR_SOCKET: "unreachable",
+    ConnectionRefused: "refused",
+    ConnectionClosed: "unreachable",
+    FailedToOpenSocket: "unreachable",
+    ERR_SOCKET_CLOSED: "unreachable"
+  };
+  BUN_CONNECT_MESSAGE = /unable to connect\. is the computer able to access the url\?/i;
+  NAME_KIND = {
+    TimeoutError: "unreachable"
+  };
+});
+
+// src/recovery/clock.ts
+function recoveryClock() {
+  return active;
+}
+var REAL_CLOCK, active;
+var init_clock = __esm(() => {
+  REAL_CLOCK = {
+    now: () => performance.now(),
+    setTimeout: (fn, ms) => setTimeout(fn, ms),
+    clearTimeout: (handle) => clearTimeout(handle),
+    unref: (handle) => {
+      handle?.unref?.();
+    }
+  };
+  active = REAL_CLOCK;
+});
+
+// src/recovery/coordinator.ts
+import { randomUUID } from "crypto";
+function hostOf2(endpoint) {
+  try {
+    return new URL(endpoint).host || endpoint;
+  } catch {
+    return endpoint;
+  }
+}
+function episodeCount() {
+  return episodes.size;
+}
+function registerRecoveryUi(hooks) {
+  uiHooks = hooks;
+}
+function uiLeaseValid(episodeId) {
+  if (!uiHooks)
+    return false;
+  try {
+    return uiHooks.leaseValid(episodeId);
+  } catch {
+    return false;
+  }
+}
+function markPaneRequested(episodeId) {
+  const ep = byId.get(episodeId);
+  if (!ep || ep.paneRequestedAtPerf !== null)
+    return;
+  ep.paneRequestedAtPerf = recoveryClock().now();
+}
+function liveEpisodes() {
+  const live = [...episodes.values()].filter((e) => e.state === "attempting" || e.state === "waiting" || e.state === "handoff");
+  live.sort((a, b) => b.waiters.size - a.waiters.size || a.startedAtMs - b.startedAtMs);
+  return live;
+}
+function renderableEpisodeFrame() {
+  const live = liveEpisodes();
+  const ep = live[0];
+  if (!ep)
+    return null;
+  const clock = recoveryClock();
+  const perfNow = clock.now();
+  const epochNow = Date.now();
+  const nextAttemptAtMs = ep.nextAttemptAtPerf === null ? null : epochNow + (ep.nextAttemptAtPerf - perfNow);
+  return {
+    type: "episode",
+    episodeId: ep.episodeId,
+    state: ep.state,
+    tier: ep.maxTier,
+    providerDisplayName: ep.providerDisplayName,
+    host: ep.host,
+    endpoint: ep.endpoint,
+    kind: ep.kind,
+    code: ep.code,
+    loopback: ep.loopback,
+    reason: ep.reason,
+    attempts: ep.attempts,
+    clientRetries: ep.clientRetries,
+    startedAtMs: ep.startedAtMs,
+    nextAttemptAtMs,
+    lastOutcome: ep.lastOutcome,
+    waiters: ep.waiters.size,
+    otherEpisodes: live.length - 1
+  };
+}
+function joinEpisode(seed) {
+  const clock = recoveryClock();
+  const host = hostOf2(seed.endpoint);
+  const key = `${seed.providerName}|${host}`;
+  let ep = episodes.get(key);
+  if (ep && (ep.state === "recovered" || ep.state === "abandoned")) {
+    episodes.delete(key);
+    ep = undefined;
+  }
+  if (ep) {
+    if (ep.state === "handoff") {
+      if (ep.graceTimer !== null) {
+        clock.clearTimeout(ep.graceTimer);
+        ep.graceTimer = null;
+      }
+      ep.clientRetries++;
+      ep.state = "attempting";
+      ep.maxTier = 2;
+      logRecovery(`[Recovery] ${ep.providerDisplayName} rejoined episode ${ep.episodeId} ` + `(client retry ${ep.clientRetries}, ladder ${ep.ladderIndex}, attempts ${ep.attempts})`);
+    }
+  } else {
+    const nowPerf = clock.now();
+    ep = {
+      episodeId: randomUUID(),
+      key,
+      providerDisplayName: seed.providerDisplayName,
+      endpoint: seed.endpoint,
+      host,
+      kind: seed.kind,
+      loopback: isLoopback(seed.endpoint),
+      code: seed.code,
+      reason: seed.reason,
+      state: "attempting",
+      startedAtPerf: nowPerf,
+      startedAtMs: Date.now(),
+      paneRequestedAtPerf: null,
+      ladderIndex: 0,
+      attempts: 0,
+      clientRetries: 0,
+      round: 0,
+      advancedForRound: 0,
+      recoveredCount: 0,
+      lastOutcome: seed.code ?? "unknown",
+      maxTier: 1,
+      waiters: new Set,
+      attemptTimer: null,
+      graceTimer: null,
+      nextAttemptAtPerf: null,
+      anyLeftByDeadline: false,
+      gaveUp: false
+    };
+    episodes.set(key, ep);
+    byId.set(ep.episodeId, ep);
+    logRecovery(`[Recovery] episode ${ep.episodeId} opened for ${ep.providerDisplayName} at ${ep.endpoint} ` + `(${ep.kind}/${ep.code ?? "?"})`);
+    if (uiHooks) {
+      try {
+        uiHooks.onEpisodeOpened(ep.episodeId);
+      } catch (err) {
+        log(`[Recovery] UI could not open for episode ${ep.episodeId}: ${String(err)}`);
+      }
+    }
+  }
+  const episode = ep;
+  const waiter = {
+    deadlineAt: seed.deadlineAt,
+    wake: null,
+    fail: null,
+    detach: null
+  };
+  episode.waiters.add(waiter);
+  let left = false;
+  return {
+    episodeId: episode.episodeId,
+    key: episode.key,
+    attempts: () => episode.attempts,
+    recoveryMs: () => Math.round(recoveryClock().now() - episode.startedAtPerf),
+    clientRetries: () => episode.clientRetries,
+    ladderIndex: () => episode.ladderIndex,
+    uiLeaseValid: () => uiLeaseValid(episode.episodeId),
+    waitForNextAttempt(signal, delayMs) {
+      if (episode.gaveUp || episode.state === "abandoned") {
+        return Promise.resolve({ kind: "gave_up" });
+      }
+      if (signal.aborted)
+        return Promise.reject(signal.reason ?? new Error("aborted"));
+      return new Promise((resolve, reject) => {
+        const onAbort = () => {
+          waiter.wake = null;
+          waiter.fail = null;
+          waiter.detach = null;
+          signal.removeEventListener("abort", onAbort);
+          reject(signal.reason ?? new Error("aborted"));
+        };
+        waiter.detach = () => signal.removeEventListener("abort", onAbort);
+        waiter.wake = (outcome) => {
+          waiter.detach?.();
+          waiter.detach = null;
+          waiter.wake = null;
+          waiter.fail = null;
+          resolve(outcome);
+        };
+        waiter.fail = (err) => {
+          waiter.detach?.();
+          waiter.detach = null;
+          waiter.wake = null;
+          waiter.fail = null;
+          reject(err);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        armAttemptTimer(episode, delayMs);
+      });
+    },
+    recordAttemptResult(outcome, ok) {
+      episode.attempts++;
+      episode.lastOutcome = outcome;
+      if (ok) {
+        episode.recoveredCount++;
+        episode.ladderIndex = 0;
+        episode.advancedForRound = episode.round;
+        episode.state = "attempting";
+        clearAttemptTimer(episode);
+        for (const w of [...episode.waiters])
+          w.wake?.({ kind: "attempt" });
+        return;
+      }
+      if (episode.advancedForRound !== episode.round) {
+        episode.advancedForRound = episode.round;
+        episode.ladderIndex++;
+      }
+      logRecovery(`[Recovery] ${episode.providerDisplayName} attempt ${episode.attempts} failed: ${outcome} ` + `(episode ${episode.episodeId}, ladder ${episode.ladderIndex})`);
+    },
+    handoff() {
+      episode.anyLeftByDeadline = true;
+    },
+    close(outcome) {
+      closeEpisode(episode, outcome);
+    },
+    leave() {
+      if (left)
+        return;
+      left = true;
+      waiter.detach?.();
+      waiter.detach = null;
+      waiter.wake = null;
+      waiter.fail = null;
+      episode.waiters.delete(waiter);
+      if (episode.waiters.size > 0)
+        return;
+      clearAttemptTimer(episode);
+      if (episode.state === "recovered" || episode.state === "abandoned") {
+        byId.delete(episode.episodeId);
+        return;
+      }
+      if (episode.recoveredCount > 0 && !episode.anyLeftByDeadline) {
+        closeEpisode(episode, "recovered");
+      } else if (episode.anyLeftByDeadline) {
+        episode.state = "handoff";
+        const c = recoveryClock();
+        const timer = c.setTimeout(() => {
+          episode.graceTimer = null;
+          closeEpisode(episode, "grace_expired");
+        }, EPISODE_GRACE_MS);
+        c.unref?.(timer);
+        episode.graceTimer = timer;
+        logRecovery(`[Recovery] episode ${episode.episodeId} handed off after ${Math.round(c.now() - episode.startedAtPerf)}ms, ${episode.attempts} attempts \u2014 holding ${EPISODE_GRACE_MS / 1000}s for a client retry`);
+      } else {
+        closeEpisode(episode, "client_gone");
+      }
+    }
+  };
+}
+function armAttemptTimer(episode, delay) {
+  if (episode.attemptTimer !== null)
+    return;
+  const clock = recoveryClock();
+  episode.state = "waiting";
+  episode.nextAttemptAtPerf = clock.now() + delay;
+  episode.attemptTimer = clock.setTimeout(() => {
+    episode.attemptTimer = null;
+    episode.nextAttemptAtPerf = null;
+    episode.state = "attempting";
+    episode.round++;
+    for (const w of [...episode.waiters])
+      w.wake?.({ kind: "attempt" });
+  }, delay);
+  logRecovery(`[Recovery] ${episode.providerDisplayName} waiting ${delay / 1000}s before attempt ` + `${episode.attempts + 1} (episode ${episode.episodeId}, ${episode.waiters.size} waiting)`);
+}
+function clearAttemptTimer(episode) {
+  if (episode.attemptTimer === null)
+    return;
+  recoveryClock().clearTimeout(episode.attemptTimer);
+  episode.attemptTimer = null;
+  episode.nextAttemptAtPerf = null;
+}
+function closeEpisode(episode, outcome) {
+  if (episode.state === "recovered" || episode.state === "abandoned")
+    return;
+  const clock = recoveryClock();
+  clearAttemptTimer(episode);
+  if (episode.graceTimer !== null) {
+    clock.clearTimeout(episode.graceTimer);
+    episode.graceTimer = null;
+  }
+  episode.state = outcome === "recovered" ? "recovered" : "abandoned";
+  if (episodes.get(episode.key) === episode)
+    episodes.delete(episode.key);
+  byId.delete(episode.episodeId);
+  if (episode.state === "abandoned") {
+    for (const w of [...episode.waiters])
+      w.wake?.({ kind: "gave_up" });
+  }
+  logRecovery(`[Recovery] episode ${episode.episodeId} closed: ${outcome} after ` + `${Math.round(clock.now() - episode.startedAtPerf)}ms and ${episode.attempts} attempts`);
+  if (uiHooks) {
+    try {
+      uiHooks.onEpisodeClosed(episode.episodeId, outcome, episode.attempts);
+    } catch {}
+  }
+}
+function noteTargetReachable(providerName, endpoint) {
+  const exact = `${providerName}|${hostOf2(endpoint)}`;
+  const prefix = `${providerName}|`;
+  for (const [key, ep] of [...episodes]) {
+    if (key !== exact && !key.startsWith(prefix))
+      continue;
+    if (ep.state !== "handoff")
+      continue;
+    logRecovery(`[Recovery] ${ep.providerDisplayName} answered on the client's own retry \u2014 ` + `closing episode ${ep.episodeId} instead of waiting out its grace`);
+    closeEpisode(ep, "recovered");
+  }
+}
+function episodeIsLive(episodeId) {
+  const ep = byId.get(episodeId);
+  if (!ep)
+    return false;
+  return ep.state === "attempting" || ep.state === "waiting" || ep.state === "handoff";
+}
+function closeAllEpisodes(outcome = "shutdown") {
+  for (const ep of [...episodes.values()])
+    closeEpisode(ep, outcome);
+  for (const ep of [...byId.values()])
+    closeEpisode(ep, outcome);
+  episodes.clear();
+  byId.clear();
+}
+var EPISODE_GRACE_MS = 120000, episodes, byId, uiHooks = null;
+var init_coordinator = __esm(() => {
+  init_connection_error();
+  init_logger();
+  init_clock();
+  episodes = new Map;
+  byId = new Map;
+});
+
+// src/config.ts
+var DEFAULT_PORT_RANGE, ENV;
+var init_config = __esm(() => {
+  DEFAULT_PORT_RANGE = { start: 3000, end: 9000 };
+  ENV = {
+    OPENROUTER_API_KEY: "OPENROUTER_API_KEY",
+    CLAUDISH_MODEL: "CLAUDISH_MODEL",
+    CLAUDISH_PORT: "CLAUDISH_PORT",
+    CLAUDISH_ACTIVE_MODEL_NAME: "CLAUDISH_ACTIVE_MODEL_NAME",
+    CLAUDISH_TOKEN_FILE: "CLAUDISH_TOKEN_FILE",
+    CLAUDISH_PROVIDER_NAME: "CLAUDISH_PROVIDER_NAME",
+    ANTHROPIC_MODEL: "ANTHROPIC_MODEL",
+    ANTHROPIC_SMALL_FAST_MODEL: "ANTHROPIC_SMALL_FAST_MODEL",
+    CLAUDISH_MODEL_OPUS: "CLAUDISH_MODEL_OPUS",
+    CLAUDISH_MODEL_SONNET: "CLAUDISH_MODEL_SONNET",
+    CLAUDISH_MODEL_HAIKU: "CLAUDISH_MODEL_HAIKU",
+    CLAUDISH_MODEL_SUBAGENT: "CLAUDISH_MODEL_SUBAGENT",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    CLAUDE_CODE_SUBAGENT_MODEL: "CLAUDE_CODE_SUBAGENT_MODEL",
+    CLAUDE_CODE_AUTO_COMPACT_WINDOW: "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
+    CLAUDE_CODE_MAX_CONTEXT_TOKENS: "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
+    OLLAMA_BASE_URL: "OLLAMA_BASE_URL",
+    OLLAMA_HOST: "OLLAMA_HOST",
+    LMSTUDIO_BASE_URL: "LMSTUDIO_BASE_URL",
+    VLLM_BASE_URL: "VLLM_BASE_URL",
+    GEMINI_API_KEY: "GEMINI_API_KEY",
+    GEMINI_BASE_URL: "GEMINI_BASE_URL",
+    OPENAI_API_KEY: "OPENAI_API_KEY",
+    OPENAI_BASE_URL: "OPENAI_BASE_URL",
+    CLAUDISH_SUMMARIZE_TOOLS: "CLAUDISH_SUMMARIZE_TOOLS",
+    CLAUDISH_DIAG_MODE: "CLAUDISH_DIAG_MODE",
+    CLAUDISH_DEBUG: "CLAUDISH_DEBUG",
+    CLAUDISH_ANTHROPIC_API_BILLING: "CLAUDISH_ANTHROPIC_API_BILLING",
+    CLAUDISH_CLASSIFIER_PROVIDER: "CLAUDISH_CLASSIFIER_PROVIDER",
+    CLAUDISH_CLASSIFIER_MODEL: "CLAUDISH_CLASSIFIER_MODEL",
+    CLAUDISH_RECOVERY: "CLAUDISH_RECOVERY",
+    CLAUDISH_RECOVERY_UI: "CLAUDISH_RECOVERY_UI",
+    API_TIMEOUT_MS: "API_TIMEOUT_MS"
+  };
+});
+
+// src/recovery/settings.ts
+function setRecoveryFlagOverrides(overrides) {
+  flagOverrides = { ...flagOverrides, ...overrides };
+}
+function parseEnvBool(raw) {
+  const v = raw?.trim().toLowerCase();
+  if (v === "1" || v === "true")
+    return true;
+  if (v === "0" || v === "false")
+    return false;
+  return;
+}
+function resolveRecoveryEnabled() {
+  if (flagOverrides.recovery !== undefined)
+    return flagOverrides.recovery;
+  const env = parseEnvBool(process.env[ENV.CLAUDISH_RECOVERY]);
+  if (env !== undefined)
+    return env;
+  const scoped = readRecoveryEnabled();
+  if (scoped !== undefined)
+    return scoped;
+  return true;
+}
+function resolveRecoveryUi() {
+  if (flagOverrides.recoveryUi !== undefined)
+    return flagOverrides.recoveryUi;
+  const env = parseEnvBool(process.env[ENV.CLAUDISH_RECOVERY_UI]);
+  if (env !== undefined)
+    return env;
+  const scoped = readRecoveryUi();
+  if (scoped !== undefined)
+    return scoped;
+  return true;
+}
+function recoverySurfaceAllowed() {
+  return resolveRecoveryEnabled() && resolveRecoveryUi();
+}
+function resolveTier1DeadlineMs(env = process.env) {
+  const raw = env[ENV.API_TIMEOUT_MS];
+  const parsed = raw === undefined ? Number.NaN : Number(raw);
+  const clientCeiling = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, CLIENT_CEILING_CLAMP_MS) : CLIENT_CEILING_CLAMP_MS;
+  const derived = clientCeiling - DEADLINE_MARGIN_MS;
+  return Math.max(TIER1_DEADLINE_FLOOR_MS, derived);
+}
+function logDeadlineIfShortened(deadlineMs) {
+  if (deadlineNoticeLogged)
+    return;
+  if (deadlineMs >= DEFAULT_TIER1_DEADLINE_MS)
+    return;
+  deadlineNoticeLogged = true;
+  const raw = process.env[ENV.API_TIMEOUT_MS];
+  log(`[Recovery] tier-1 hold shortened to ${Math.round(deadlineMs / 1000)}s ` + `(API_TIMEOUT_MS=${raw ?? "unset"}; default would be ${Math.round(DEFAULT_TIER1_DEADLINE_MS / 1000)}s)`);
+}
+function retryWatchdogEnv(opts) {
+  if (!opts.paneEligible)
+    return {};
+  return recoverySurfaceAllowed() ? { CLAUDE_CODE_RETRY_WATCHDOG: "1" } : {};
+}
+function applyRetryWatchdog(env, opts) {
+  const grant = retryWatchdogEnv(opts);
+  if (grant.CLAUDE_CODE_RETRY_WATCHDOG) {
+    const usersOwn = env.CLAUDE_CODE_RETRY_WATCHDOG !== undefined && env[RETRY_WATCHDOG_OWNER_ENV] !== "1";
+    Object.assign(env, grant);
+    if (!usersOwn)
+      env[RETRY_WATCHDOG_OWNER_ENV] = "1";
+    return;
+  }
+  if (env[RETRY_WATCHDOG_OWNER_ENV] === "1") {
+    delete env.CLAUDE_CODE_RETRY_WATCHDOG;
+    delete env[RETRY_WATCHDOG_OWNER_ENV];
+  }
+}
+var flagOverrides, CLIENT_CEILING_CLAMP_MS = 300000, DEADLINE_MARGIN_MS = 30000, TIER1_DEADLINE_FLOOR_MS = 15000, DEFAULT_TIER1_DEADLINE_MS, deadlineNoticeLogged = false, RETRY_WATCHDOG_OWNER_ENV = "CLAUDISH_SET_RETRY_WATCHDOG";
+var init_settings = __esm(() => {
+  init_config();
+  init_logger();
+  init_profile_config();
+  flagOverrides = {};
+  DEFAULT_TIER1_DEADLINE_MS = CLIENT_CEILING_CLAMP_MS - DEADLINE_MARGIN_MS;
+});
+
+// src/handlers/shared/transient-retry.ts
+function connectionRetryDelayMs(ladderIndex) {
+  const i = Math.max(0, Math.min(ladderIndex, CONNECTION_RETRY_DELAYS_MS.length - 1));
+  return CONNECTION_RETRY_DELAYS_MS[i];
+}
+function refreshDeadlineAt(deadlineAt) {
+  const reserve = Math.min(PER_ATTEMPT_CONNECT_CAP_MS, resolveTier1DeadlineMs() / 2);
+  return deadlineAt - reserve;
+}
+function inboundStartedAtPerf(c) {
+  const key = c.req?.raw;
+  if (!key)
+    return recoveryClock().now();
+  const seen = INBOUND_START.get(key);
+  if (seen !== undefined)
+    return seen;
+  const t = recoveryClock().now();
+  INBOUND_START.set(key, t);
+  return t;
+}
+function tier1DeadlineAt(c) {
+  return inboundStartedAtPerf(c) + resolveTier1DeadlineMs();
+}
+function noteDeadlineForEpisode() {
+  logDeadlineIfShortened(resolveTier1DeadlineMs());
+}
+function deadlineClamp(deadlineAt) {
+  const clock = recoveryClock();
+  const remaining = deadlineAt - clock.now();
+  if (!(remaining > 0))
+    return { disarm: () => {} };
+  const ac = new AbortController;
+  const timer = clock.setTimeout(() => ac.abort(markOwnTimeout(new DOMException("request deadline", "TimeoutError"))), remaining);
+  return {
+    signal: ac.signal,
+    disarm: () => clock.clearTimeout(timer)
+  };
+}
+function mergeSignalIntoInit(init, signal) {
+  if (!signal)
+    return init;
+  const own = init.signal;
+  if (!own || own.aborted)
+    return { ...init, signal };
+  return { ...init, signal: AbortSignal.any([own, signal]) };
+}
+function isClientAbort(signal, err) {
+  if (signal.aborted)
+    return true;
+  return err?.name === "AbortError";
+}
+function untilAborted(p, signal) {
+  if (signal.aborted) {
+    p.catch(() => {});
+    return Promise.reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      reject(signal.reason ?? new DOMException("aborted", "AbortError"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    p.then((v) => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(v);
+    }, (e) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(e);
+    });
+  });
+}
+async function withConnectionRetry(op, first, ctx) {
+  const clock = recoveryClock();
+  const enteredAtPerf = clock.now();
+  let requestRetries = 0;
+  const firstConn = classifyConnectionError(first);
+  if (!firstConn) {
+    return {
+      kind: "threw",
+      error: first,
+      attempts: 0,
+      recoveryMs: 0,
+      requestRetries: 0,
+      requestRecoveryMs: 0,
+      clientRetry: 0,
+      episodeId: ""
+    };
+  }
+  let conn = firstConn;
+  let error = first;
+  let endpoint = ctx.resolveEndpoint(first);
+  noteDeadlineForEpisode();
+  const handle = joinEpisode({
+    providerName: ctx.providerName,
+    providerDisplayName: ctx.providerDisplayName,
+    endpoint,
+    kind: conn.kind,
+    code: conn.code,
+    reason: buildConnectionErrorMessage(conn.kind, ctx.providerDisplayName, endpoint),
+    deadlineAt: ctx.deadlineAt
+  });
+  const tally = () => ({
+    attempts: handle.attempts(),
+    recoveryMs: handle.recoveryMs(),
+    requestRetries,
+    requestRecoveryMs: Math.round(clock.now() - enteredAtPerf),
+    clientRetry: handle.clientRetries(),
+    episodeId: handle.episodeId
+  });
+  try {
+    handle.recordAttemptResult(conn.code, false);
+    for (;; ) {
+      if (ctx.signal.aborted) {
+        return { kind: "client_gone", ...tally() };
+      }
+      const waitBudget = ctx.deadlineAt - clock.now() - MIN_ATTEMPT_SLOT_MS;
+      let delay = connectionRetryDelayMs(handle.ladderIndex());
+      if (delay > waitBudget) {
+        const mayTruncate = requestRetries === 0 && waitBudget >= MIN_ATTEMPT_SLOT_MS;
+        if (!mayTruncate) {
+          handle.handoff();
+          return { kind: "exhausted", conn, error, endpoint, ...tally() };
+        }
+        delay = waitBudget;
+      }
+      let waited;
+      try {
+        waited = await handle.waitForNextAttempt(ctx.signal, delay);
+      } catch (err) {
+        if (isClientAbort(ctx.signal, err)) {
+          log(`[Recovery] client gone during wait (episode ${handle.episodeId})`);
+          return { kind: "client_gone", ...tally() };
+        }
+        throw err;
+      }
+      if (waited.kind === "gave_up") {
+        return { kind: "gave_up", conn, error, endpoint, ...tally() };
+      }
+      const attemptAc = new AbortController;
+      const remaining = ctx.deadlineAt - clock.now();
+      const clampMs = Math.max(MIN_ATTEMPT_SLOT_MS, Math.min(PER_ATTEMPT_CONNECT_CAP_MS, remaining));
+      const clampTimer = clock.setTimeout(() => attemptAc.abort(markOwnTimeout(new DOMException("attempt cap", "TimeoutError"))), clampMs);
+      const merged = AbortSignal.any([ctx.signal, attemptAc.signal]);
+      try {
+        requestRetries++;
+        const value = await untilAborted(op(merged), merged);
+        handle.recordAttemptResult("ok", true);
+        logRecovery(`[Recovery] ${ctx.providerDisplayName} recovered after ${handle.attempts()} attempts ` + `in ${handle.recoveryMs()}ms (episode ${handle.episodeId})`);
+        return { kind: "ok", value, ...tally() };
+      } catch (err) {
+        if (isClientAbort(ctx.signal, err)) {
+          log(`[Recovery] client gone during attempt (episode ${handle.episodeId})`);
+          return { kind: "client_gone", ...tally() };
+        }
+        const next = classifyConnectionError(err);
+        if (!next) {
+          return { kind: "threw", error: err, ...tally() };
+        }
+        conn = next;
+        error = err;
+        endpoint = ctx.resolveEndpoint(err) || endpoint;
+        handle.recordAttemptResult(next.code, false);
+      } finally {
+        clock.clearTimeout(clampTimer);
+      }
+    }
+  } finally {
+    handle.leave();
+  }
+}
+var CONNECTION_RETRY_DELAYS_MS, PER_ATTEMPT_CONNECT_CAP_MS = 45000, MIN_ATTEMPT_SLOT_MS = 3000, TOKEN_REFRESH_TIMEOUT_MS = 20000, INBOUND_START;
+var init_transient_retry = __esm(() => {
+  init_logger();
+  init_clock();
+  init_coordinator();
+  init_settings();
+  init_connection_error();
+  init_coordinator();
+  CONNECTION_RETRY_DELAYS_MS = [5000, 1e4, 30000, 60000];
+  INBOUND_START = new WeakMap;
+});
+
 // src/providers/grok/grok-credentials.ts
 import { existsSync as existsSync11, readFileSync as readFileSync10, renameSync, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir13 } from "os";
@@ -25070,10 +25842,11 @@ async function performRefresh(cred) {
     response = await fetch(tokenEndpoint, {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body
+      body,
+      signal: AbortSignal.timeout(TOKEN_REFRESH_TIMEOUT_MS)
     });
   } catch (error) {
-    throw new Error(`Could not reach ${tokenEndpoint} to refresh the Grok token: ${error.message}`);
+    throw Object.assign(new Error(`Could not reach ${tokenEndpoint} to refresh the Grok token: ${error.message}`, { cause: markOwnTimeout(error) }), { claudishEndpoint: tokenEndpoint });
   }
   const text = await response.text();
   if (!response.ok) {
@@ -25137,6 +25910,8 @@ function refreshShared(cred) {
 var GROK_PROXY_URL_ENV = "GROK_PROXY_URL", DEFAULT_GROK_PROXY_URL = "https://cli-chat-proxy.grok.com/v1", GROK_CLIENT_IDENTIFIER = "grok-shell", FALLBACK_GROK_CLIENT_VERSION = "1.0.4", LEGACY_SCOPE = "https://accounts.x.ai/sign-in", EXPIRY_SKEW_MS2, grokHomeOverride = null, claudishOAuthPathOverride = null, GROK_CHANNEL_URL = "https://x.ai/cli/stable", liveClientVersion = null, SIGN_IN_HINT, refreshInFlight = null;
 var init_grok_credentials = __esm(() => {
   init_grok_oauth();
+  init_connection_error();
+  init_transient_retry();
   EXPIRY_SKEW_MS2 = 5 * 60 * 1000;
   SIGN_IN_HINT = "Run `claudish login grok` (no Grok CLI required \u2014 SuperGrok or X Premium+ subscription). " + "An existing `grok login` (~/.grok/auth.json) is also picked up automatically.";
 });
@@ -25461,7 +26236,7 @@ function globMatches(pattern, value) {
   return new RegExp(`^${escaped}$`).test(value);
 }
 var SeveritySchema, BehaviorConfigSchema;
-var init_config = __esm(() => {
+var init_config2 = __esm(() => {
   init_zod();
   init_logger();
   SeveritySchema = _enum(["off", "warn", "fix"]);
@@ -26482,7 +27257,7 @@ class BehaviorEngine {
 var MAX_OBSERVED_CHARS, MAX_OBSERVED_TOOLS = 200, MAX_TRACKED_CONVERSATIONS = 64;
 var init_engine = __esm(() => {
   init_logger();
-  init_config();
+  init_config2();
   init_harness();
   init_journal();
   init_aggregate();
@@ -26790,12 +27565,12 @@ function registerHookRules(rules) {
 var BUILTIN_RULES, sharedEngine = null, hookRules;
 var init_behavior = __esm(() => {
   init_profile_config();
-  init_config();
+  init_config2();
   init_engine();
   init_plan_mode();
   init_session_context();
   init_engine();
-  init_config();
+  init_config2();
   init_harness();
   init_hooks();
   init_digest();
@@ -27303,7 +28078,7 @@ var init_gemini_queue = __esm(() => {
 });
 
 // src/providers/transport/antigravity.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function antigravityEndpoint() {
   return `${antigravityHost()}/v1internal:streamGenerateContent?alt=sse`;
 }
@@ -27481,7 +28256,7 @@ class AntigravityProviderTransport {
     const envelope = {
       model,
       project: this.projectId,
-      user_prompt_id: randomUUID(),
+      user_prompt_id: randomUUID2(),
       request: innerPayload
     };
     if (this.tierId && this.tierId !== "free-tier") {
@@ -27735,7 +28510,7 @@ function redactSecrets(text) {
 }
 
 // src/auth/credentials/antigravity-credential.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 function createActivityRequestId2() {
   return Math.random().toString(36).substring(7);
 }
@@ -27770,7 +28545,7 @@ class AntigravityCredentialProvider {
         const env = {
           model: servedModel,
           project: projectId,
-          user_prompt_id: randomUUID2(),
+          user_prompt_id: randomUUID3(),
           request: inner
         };
         if (tierId && tierId !== "free-tier") {
@@ -28407,8 +29182,9 @@ class CodexOAuth {
       throw new Error("No OpenAI Codex OAuth credentials found. Please run `claudish login codex` first.");
     }
     log("[CodexOAuth] Refreshing access token");
+    let response;
     try {
-      const response = await fetch(OAUTH_CONFIG.tokenUrl, {
+      response = await fetch(OAUTH_CONFIG.tokenUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
@@ -28417,8 +29193,14 @@ class CodexOAuth {
           grant_type: "refresh_token",
           refresh_token: this.credentials.refresh_token,
           client_id: OAUTH_CONFIG.clientId
-        })
+        }),
+        signal: AbortSignal.timeout(TOKEN_REFRESH_TIMEOUT_MS)
       });
+    } catch (e) {
+      log(`[CodexOAuth] Could not reach ${OAUTH_CONFIG.tokenUrl}: ${e.message}`);
+      throw Object.assign(new Error(`Could not reach ${OAUTH_CONFIG.tokenUrl} to refresh the Codex token: ${e.message}`, { cause: markOwnTimeout(e) }), { claudishEndpoint: OAUTH_CONFIG.tokenUrl });
+    }
+    try {
       if (!response.ok) {
         const errorText = await response.text();
         throw new Error(`Token refresh failed: ${response.status} - ${errorText}`);
@@ -28439,7 +29221,7 @@ class CodexOAuth {
       log(`[CodexOAuth] Refresh failed: ${e.message}`);
       throw new Error(`OAuth credentials invalid. Please run \`claudish login codex\` again.
 
-Details: ${e.message}`);
+Details: ${e.message}`, { cause: e });
     }
   }
   loadCredentials() {
@@ -28666,6 +29448,8 @@ function getCodexOAuth() {
 }
 var execAsync3, OAUTH_CONFIG;
 var init_codex_oauth = __esm(() => {
+  init_connection_error();
+  init_transient_retry();
   init_logger();
   execAsync3 = promisify3(exec3);
   OAUTH_CONFIG = {
@@ -29804,14 +30588,14 @@ var init_proto_codec = __esm(() => {
 });
 
 // src/providers/devin/devin-request.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 function encodeChatMetadata(meta) {
   const version = meta.clientVersion ?? DEVIN_CLI_VERSION;
   return msg(bytes(1, "devin-cli"), bytes(2, version), bytes(3, meta.apiKey), bytes(4, "en"), bytes(5, meta.platform ?? process.platform), bytes(7, version), bytes(12, "chisel"), bytes(28, "chisel"));
 }
 function encodeMessage(message) {
   const parts = [
-    bytes(1, message.id ?? randomUUID3()),
+    bytes(1, message.id ?? randomUUID4()),
     vint(2, DEVIN_ROLE[message.role])
   ];
   if (message.text)
@@ -31266,11 +32050,11 @@ class OpenAIProviderTransport {
       } catch (fetchError) {
         if (fetchError.name === "AbortError") {
           log(`[${this.displayName}] Request timed out after 30s`);
-          throw new OpenAITimeoutError(this.provider.baseUrl);
+          throw new OpenAITimeoutError(this.provider.baseUrl, fetchError);
         }
         if (fetchError.cause?.code === "UND_ERR_CONNECT_TIMEOUT") {
           log(`[${this.displayName}] Connection timeout: ${fetchError.message}`);
-          throw new OpenAIConnectionError(this.provider.baseUrl, fetchError.cause?.code);
+          throw new OpenAIConnectionError(this.provider.baseUrl, fetchError.cause?.code, fetchError);
         }
         throw fetchError;
       }
@@ -31305,15 +32089,20 @@ var init_openai = __esm(() => {
   init_logger();
   init_provider_model_discovery();
   OpenAITimeoutError = class OpenAITimeoutError extends Error {
-    constructor(baseUrl) {
-      super(`Request to OpenAI API timed out. Check your network connection to ${baseUrl}`);
+    code = "ETIMEDOUT";
+    constructor(baseUrl, cause) {
+      super(`Request to OpenAI API timed out. Check your network connection to ${baseUrl}`, {
+        cause
+      });
       this.name = "OpenAITimeoutError";
     }
   };
   OpenAIConnectionError = class OpenAIConnectionError extends Error {
-    constructor(baseUrl, code) {
-      super(`Cannot connect to OpenAI API (${baseUrl}). This may be due to: network/firewall blocking, VPN interference, or regional restrictions. Error: ${code}`);
+    code;
+    constructor(baseUrl, code, cause) {
+      super(`Cannot connect to OpenAI API (${baseUrl}). This may be due to: network/firewall blocking, VPN interference, or regional restrictions. Error: ${code}`, { cause });
       this.name = "OpenAIConnectionError";
+      this.code = code;
     }
   };
 });
@@ -32188,6 +32977,21 @@ function eventToLogRecord(event) {
   if (event.fallback_attempts !== undefined) {
     attributes.push(intAttr("llm.fallback_attempts", event.fallback_attempts));
   }
+  if (event.retry_attempts !== undefined) {
+    attributes.push(intAttr("llm.retry_attempts", event.retry_attempts));
+  }
+  if (event.recovery_ms !== undefined) {
+    attributes.push(intAttr("llm.recovery_ms", event.recovery_ms));
+  }
+  if (event.recovery_episode_id !== undefined) {
+    attributes.push(stringAttr("llm.recovery_episode_id", event.recovery_episode_id));
+  }
+  if (event.recovery_client_retry !== undefined) {
+    attributes.push(intAttr("llm.recovery_client_retry", event.recovery_client_retry));
+  }
+  if (event.recovery_outcome !== undefined) {
+    attributes.push(stringAttr("llm.recovery_outcome", event.recovery_outcome));
+  }
   return {
     timeUnixNano,
     severityNumber: 9,
@@ -32726,6 +33530,16 @@ function recordStats(partial) {
       event.fallback_chain = partial.fallback_chain;
     if (partial.fallback_attempts !== undefined)
       event.fallback_attempts = partial.fallback_attempts;
+    if (partial.retry_attempts !== undefined)
+      event.retry_attempts = partial.retry_attempts;
+    if (partial.recovery_ms !== undefined)
+      event.recovery_ms = partial.recovery_ms;
+    if (partial.recovery_episode_id !== undefined)
+      event.recovery_episode_id = partial.recovery_episode_id;
+    if (partial.recovery_client_retry !== undefined)
+      event.recovery_client_retry = partial.recovery_client_retry;
+    if (partial.recovery_outcome !== undefined)
+      event.recovery_outcome = partial.recovery_outcome;
     appendEvent(event);
     checkAndFlush();
   } catch {}
@@ -33291,79 +34105,6 @@ var init_collect_sse_message = __esm(() => {
   init_logger();
 });
 
-// src/handlers/shared/connection-error.ts
-function findConnectionCode(error) {
-  let e = error;
-  const seen = new Set;
-  for (let depth = 0;e && typeof e === "object" && depth < 8 && !seen.has(e); depth++) {
-    seen.add(e);
-    if (typeof e.code === "string" && e.code in CODE_KIND)
-      return e.code;
-    e = e.cause;
-  }
-  const msg = String(error?.message ?? error ?? "");
-  if (/getaddrinfo|ENOTFOUND|EAI_AGAIN|nodename nor servname/i.test(msg))
-    return "ENOTFOUND";
-  if (BUN_CONNECT_MESSAGE.test(msg))
-    return "ConnectionRefused";
-  return null;
-}
-function isLoopback(endpoint) {
-  try {
-    const { hostname } = new URL(endpoint);
-    return /^(localhost|127\.\d+\.\d+\.\d+|0\.0\.0\.0|\[?::1\]?)$/i.test(hostname);
-  } catch {
-    return false;
-  }
-}
-function classifyConnectionError(error) {
-  const code = findConnectionCode(error);
-  if (!code)
-    return null;
-  return { kind: CODE_KIND[code] ?? "unreachable", code };
-}
-function hostOf(endpoint) {
-  try {
-    return new URL(endpoint).host || endpoint;
-  } catch {
-    return endpoint;
-  }
-}
-function buildConnectionErrorMessage(kind, displayName, endpoint) {
-  const host = hostOf(endpoint);
-  switch (kind) {
-    case "dns":
-      return `Cannot resolve ${host} for ${displayName}. This is a DNS/network problem on your machine \u2014 check your internet connection, VPN, or DNS resolver (e.g. Tailscale MagicDNS) \u2014 not ${displayName}.`;
-    case "refused":
-      if (isLoopback(endpoint)) {
-        return `Cannot connect to ${displayName} at ${endpoint}. Make sure the server is running.`;
-      }
-      return `Cannot reach ${host} for ${displayName}. This is a network problem on your machine \u2014 check your internet connection, VPN, or DNS resolver (e.g. Tailscale MagicDNS) \u2014 not ${displayName}.`;
-    case "unreachable":
-      return `Cannot reach ${displayName} at ${endpoint}. Check your network connection.`;
-  }
-}
-var CODE_KIND, BUN_CONNECT_MESSAGE;
-var init_connection_error = __esm(() => {
-  CODE_KIND = {
-    ENOTFOUND: "dns",
-    EAI_AGAIN: "dns",
-    ECONNREFUSED: "refused",
-    ETIMEDOUT: "unreachable",
-    ECONNRESET: "unreachable",
-    ENETUNREACH: "unreachable",
-    EHOSTUNREACH: "unreachable",
-    EPIPE: "unreachable",
-    UND_ERR_CONNECT_TIMEOUT: "unreachable",
-    UND_ERR_SOCKET: "unreachable",
-    ConnectionRefused: "refused",
-    ConnectionClosed: "unreachable",
-    FailedToOpenSocket: "unreachable",
-    ERR_SOCKET_CLOSED: "unreachable"
-  };
-  BUN_CONNECT_MESSAGE = /unable to connect\. is the computer able to access the url\?/i;
-});
-
 // src/handlers/shared/devin-stream-head-sniffer.ts
 function classifyDevinStreamError(code, message) {
   const lowerCode = code.toLowerCase();
@@ -33513,6 +34254,39 @@ var init_model_unsupported = __esm(() => {
   PARAMETER_IS_UNSUPPORTED = /\b(thinking[ _-]?(level|budget)|reasoning[ _-]?effort|effort|temperature|top[_ ]?[pk]|tool[_ ]?choice|tools?|function[ _-]?calling|parameter|argument|field|image[s]?|audio|video|streaming|stream|json[ _-]?mode|response[ _-]?format|system[ _-]?(prompt|instruction)s?)\b[^.]{0,60}?\b(is|are|was|were)?\s*not supported\b/;
 });
 
+// src/handlers/shared/recovery-marker.ts
+function recoveryHoldHeaders() {
+  return {
+    "content-type": "application/json",
+    "x-should-retry": "true",
+    [RECOVERY_MARKER_HEADER]: RECOVERY_MARKER_VALUE
+  };
+}
+function connectionFaultHeaders() {
+  return { [CONNECTION_FAULT_HEADER]: RECOVERY_MARKER_VALUE };
+}
+function hasRecoveryMarker(headers) {
+  try {
+    return headers?.get(RECOVERY_MARKER_HEADER) === RECOVERY_MARKER_VALUE;
+  } catch {
+    return false;
+  }
+}
+function hasConnectionFaultMarker(headers) {
+  try {
+    return headers?.get(CONNECTION_FAULT_HEADER) === RECOVERY_MARKER_VALUE;
+  } catch {
+    return false;
+  }
+}
+function isClaudishConnectionVerdict(headers) {
+  return hasRecoveryMarker(headers) || hasConnectionFaultMarker(headers);
+}
+function isRecoveryHoldResponse(response) {
+  return hasRecoveryMarker(response?.headers);
+}
+var RECOVERY_MARKER_HEADER = "x-claudish-recovery", RECOVERY_MARKER_VALUE = "1", CONNECTION_FAULT_HEADER = "x-claudish-connection-error";
+
 // src/handlers/shared/stream-head-sniffer.ts
 function isRetryableStreamError(code, type, message) {
   if (RETRYABLE_ERROR_CODES.has(code))
@@ -35628,11 +36402,204 @@ class ComposedHandler {
       return this.modelAdapter.getName();
     return this.getAdapter().getName();
   }
+  connectionEndpointFor(error, requestEndpoint) {
+    const attached = error?.claudishEndpoint;
+    if (typeof attached === "string" && attached.length > 0)
+      return attached;
+    if (requestEndpoint)
+      return requestEndpoint;
+    try {
+      return this.provider.getEndpoint(this.targetModel);
+    } catch {
+      return this.provider.displayName;
+    }
+  }
+  static newRecoveryTally() {
+    return { retries: 0, recoveryMs: 0, clientRetry: 0 };
+  }
+  recoveryStats(tally) {
+    if (!tally?.episodeId)
+      return {};
+    return {
+      retry_attempts: tally.retries,
+      recovery_ms: tally.recoveryMs,
+      recovery_episode_id: tally.episodeId,
+      recovery_client_retry: tally.clientRetry,
+      ...tally.outcome ? { recovery_outcome: tally.outcome } : {}
+    };
+  }
+  respondConnectionError(c, error, conn, endpoint, ctx) {
+    const msg = buildConnectionErrorMessage(conn.kind, this.provider.displayName, endpoint);
+    log(`[${this.provider.displayName}] ${msg} (code=${conn.code}${ctx.site ? `, site=${ctx.site}` : ""})`);
+    logStderr(`Error: ${msg}`);
+    reportError({
+      error,
+      providerName: this.provider.name,
+      providerDisplayName: this.provider.displayName,
+      streamFormat: this.provider.streamFormat,
+      modelId: this.targetModel,
+      httpStatus: undefined,
+      isStreaming: false,
+      retryAttempted: (ctx.retriedBeforeLadder ?? false) || (ctx.recovery?.retries ?? 0) > 0,
+      isInteractive: this.isInteractive,
+      ...ctx.authType ? { authType: ctx.authType } : {}
+    });
+    try {
+      const { error_class, error_code } = classifyError(error, undefined);
+      recordStats({
+        model_id: this.targetModel,
+        provider_name: this.provider.name,
+        stream_format: this.provider.streamFormat,
+        latency_ms: Math.round(performance.now() - ctx.startTime),
+        success: false,
+        http_status: 0,
+        error_class,
+        error_code,
+        token_strategy: this.options.tokenStrategy ?? "standard",
+        adapter_name: this.getActiveAdapterName(),
+        middleware_names: this.middlewareManager.getActiveNames(this.bareModelName),
+        fallback_used: ctx.fallbackMeta !== undefined,
+        fallback_chain: ctx.fallbackMeta?.chain,
+        fallback_attempts: ctx.fallbackMeta?.attempts,
+        invocation_mode: this.options.invocationMode ?? "auto-route",
+        ...this.recoveryStats(ctx.recovery)
+      });
+    } catch {}
+    return c.json(wrapAnthropicError(400, msg, "connection_error"), 400, connectionFaultHeaders());
+  }
+  respondRecoveryHold(error, conn, endpoint, ctx) {
+    const reason = buildConnectionErrorMessage(conn.kind, this.provider.displayName, endpoint);
+    const msg = buildRecoveryHoldMessage(reason, ctx.attempts, ctx.recoveryMs);
+    try {
+      const { error_class, error_code } = classifyError(error, undefined);
+      recordStats({
+        model_id: this.targetModel,
+        provider_name: this.provider.name,
+        stream_format: this.provider.streamFormat,
+        latency_ms: Math.round(performance.now() - ctx.startTime),
+        success: false,
+        http_status: 503,
+        error_class,
+        error_code,
+        token_strategy: this.options.tokenStrategy ?? "standard",
+        adapter_name: this.getActiveAdapterName(),
+        middleware_names: this.middlewareManager.getActiveNames(this.bareModelName),
+        fallback_used: ctx.fallbackMeta !== undefined,
+        fallback_chain: ctx.fallbackMeta?.chain,
+        fallback_attempts: ctx.fallbackMeta?.attempts,
+        invocation_mode: this.options.invocationMode ?? "auto-route",
+        ...this.recoveryStats(ctx.recovery)
+      });
+    } catch {}
+    return new Response(JSON.stringify(wrapAnthropicError(503, msg, "overloaded_error")), {
+      status: 503,
+      headers: recoveryHoldHeaders()
+    });
+  }
+  clientSignal(c) {
+    try {
+      const signal = c.req?.raw?.signal;
+      if (signal)
+        return signal;
+    } catch {}
+    return new AbortController().signal;
+  }
+  shouldSkipTier1(c, deadlineAt) {
+    if (c.req.header("x-claudish-no-recovery") === "1")
+      return "probe";
+    if (!resolveRecoveryEnabled())
+      return "recovery-disabled";
+    if (recoveryClock().now() + MIN_ATTEMPT_SLOT_MS > deadlineAt)
+      return "no-budget";
+    return null;
+  }
+  async recoverConnection(c, first, conn, endpoint, op, ctx) {
+    const skip = this.shouldSkipTier1(c, ctx.deadlineAt);
+    if (skip) {
+      log(`[Recovery] skipped (${skip}) \u2014 ${this.provider.displayName} at ${endpoint}, site=${ctx.site}`);
+      return {
+        kind: "respond",
+        response: this.respondConnectionError(c, first, conn, endpoint, ctx)
+      };
+    }
+    try {
+      c.env?.timeout?.(c.req.raw, 0);
+    } catch {}
+    const result = await withConnectionRetry(op, first, {
+      providerName: this.provider.name,
+      providerDisplayName: this.provider.displayName,
+      resolveEndpoint: (err) => this.connectionEndpointFor(err, endpoint),
+      deadlineAt: ctx.deadlineAt,
+      signal: this.clientSignal(c)
+    });
+    ctx.recovery.retries += result.requestRetries;
+    ctx.recovery.recoveryMs += result.requestRecoveryMs;
+    ctx.recovery.episodeId = result.episodeId;
+    ctx.recovery.clientRetry = result.clientRetry;
+    switch (result.kind) {
+      case "ok":
+        ctx.recovery.outcome = "recovered";
+        return { kind: "value", value: result.value };
+      case "threw":
+        throw result.error;
+      case "client_gone":
+        ctx.recovery.outcome = "client_gone";
+        this.recordClientGone(ctx.startTime, ctx.fallbackMeta, result.episodeId, result.attempts, ctx.recovery);
+        return { kind: "respond", response: new Response(null, { status: 499 }) };
+      default: {
+        const leased = uiLeaseValid(result.episodeId);
+        ctx.recovery.outcome = result.kind === "exhausted" ? "handoff" : "gave_up";
+        if (result.kind === "exhausted" && leased) {
+          logRecovery(`[Recovery] ${this.provider.displayName} exhausted after ${result.attempts} attempts ` + `in ${result.recoveryMs}ms (episode ${result.episodeId}, ui_lease=true) \u2014 ` + "handing the retry back to the client (503, tier 2)");
+          return {
+            kind: "respond",
+            response: this.respondRecoveryHold(result.error, result.conn, result.endpoint, {
+              startTime: ctx.startTime,
+              attempts: result.attempts,
+              recoveryMs: result.recoveryMs,
+              fallbackMeta: ctx.fallbackMeta,
+              recovery: ctx.recovery
+            })
+          };
+        }
+        logRecovery(`[Recovery] ${this.provider.displayName} exhausted after ${result.attempts} attempts ` + `in ${result.recoveryMs}ms (episode ${result.episodeId}, outcome ${result.kind}, ` + `ui_lease=${leased}) \u2014 answering connection_error`);
+        return {
+          kind: "respond",
+          response: this.respondConnectionError(c, result.error, result.conn, result.endpoint, ctx)
+        };
+      }
+    }
+  }
+  recordClientGone(startTime, fallbackMeta, episodeId, attempts, recovery) {
+    log(`[Recovery] client disconnected after ${attempts} attempts (episode ${episodeId}) \u2014 ` + "releasing the request");
+    try {
+      recordStats({
+        model_id: this.targetModel,
+        provider_name: this.provider.name,
+        stream_format: this.provider.streamFormat,
+        latency_ms: Math.round(performance.now() - startTime),
+        success: false,
+        http_status: 0,
+        error_class: "network",
+        error_code: "client_disconnected",
+        token_strategy: this.options.tokenStrategy ?? "standard",
+        adapter_name: this.getActiveAdapterName(),
+        middleware_names: this.middlewareManager.getActiveNames(this.bareModelName),
+        fallback_used: fallbackMeta !== undefined,
+        fallback_chain: fallbackMeta?.chain,
+        fallback_attempts: fallbackMeta?.attempts,
+        invocation_mode: this.options.invocationMode ?? "auto-route",
+        ...this.recoveryStats(recovery)
+      });
+    } catch {}
+  }
   async handle(c, payload) {
     const startTime = performance.now();
+    inboundStartedAtPerf(c);
     let latencyMs = 0;
     const fallbackMeta = this.pendingFallbackMeta;
     this.pendingFallbackMeta = undefined;
+    const recoveryTally = ComposedHandler.newRecoveryTally();
     const { claudeRequest, droppedParams } = transformOpenAIToClaude(payload);
     const adapter = this.getAdapter();
     if (typeof adapter.reset === "function")
@@ -35764,28 +36731,42 @@ class ComposedHandler {
     if (this.provider.refreshAuth) {
       try {
         await this.provider.refreshAuth();
-        if (this.provider.displayName) {
-          this.tokenTracker.setProviderDisplayName(this.provider.displayName);
-        }
       } catch (err) {
-        log(`[${this.provider.displayName}] Auth/health check failed: ${err.message}`);
-        logStderr(`Error [${this.provider.displayName}]: Auth/health check failed \u2014 ${err.message}. Check credentials and server.`);
-        reportError({
-          error: err,
-          providerName: this.provider.name,
-          providerDisplayName: this.provider.displayName,
-          streamFormat: this.provider.streamFormat,
-          modelId: this.targetModel,
-          httpStatus: 401,
-          isStreaming: false,
-          retryAttempted: false,
-          isInteractive: this.isInteractive,
-          authType: "oauth"
-        });
-        if (err?.terminal) {
-          return c.json(wrapAnthropicError(400, err.message, "invalid_request_error"), 400);
+        const conn = classifyConnectionError(err);
+        if (conn) {
+          const outcome = await this.recoverConnection(c, err, conn, this.connectionEndpointFor(err), () => this.provider.refreshAuth(), {
+            startTime,
+            deadlineAt: refreshDeadlineAt(tier1DeadlineAt(c)),
+            fallbackMeta,
+            authType: "oauth",
+            site: "refreshAuth",
+            recovery: recoveryTally
+          });
+          if (outcome.kind === "respond")
+            return outcome.response;
+        } else {
+          log(`[${this.provider.displayName}] Auth/health check failed: ${err.message}`);
+          logStderr(`Error [${this.provider.displayName}]: Auth/health check failed \u2014 ${err.message}. Check credentials and server.`);
+          reportError({
+            error: err,
+            providerName: this.provider.name,
+            providerDisplayName: this.provider.displayName,
+            streamFormat: this.provider.streamFormat,
+            modelId: this.targetModel,
+            httpStatus: 401,
+            isStreaming: false,
+            retryAttempted: false,
+            isInteractive: this.isInteractive,
+            authType: "oauth"
+          });
+          if (err?.terminal) {
+            return c.json(wrapAnthropicError(400, err.message, "invalid_request_error"), 400);
+          }
+          return c.json(wrapAnthropicError(401, err.message, "authentication_error"), 401);
         }
-        return c.json(wrapAnthropicError(401, err.message, "authentication_error"), 401);
+      }
+      if (this.provider.displayName) {
+        this.tokenTracker.setProviderDisplayName(this.provider.displayName);
       }
     }
     if (this.provider.getContextWindow) {
@@ -35798,61 +36779,72 @@ class ComposedHandler {
       requestPayload = this.provider.transformPayload(requestPayload, claudeRequest);
     }
     const endpoint = this.provider.getEndpoint(this.targetModel);
-    const headers = await this.provider.getHeaders(payload);
+    let headers;
+    try {
+      headers = await this.provider.getHeaders(payload);
+    } catch (err) {
+      const conn = classifyConnectionError(err);
+      if (!conn) {
+        throw err;
+      }
+      const outcome = await this.recoverConnection(c, err, conn, this.connectionEndpointFor(err, endpoint), () => this.provider.getHeaders(), {
+        startTime,
+        deadlineAt: refreshDeadlineAt(tier1DeadlineAt(c)),
+        fallbackMeta,
+        authType: "oauth",
+        site: "getHeaders",
+        recovery: recoveryTally
+      });
+      if (outcome.kind === "respond")
+        return outcome.response;
+      headers = outcome.value;
+    }
     const serialized = this.provider.serializeBody?.(requestPayload);
     headers["Content-Type"] = serialized?.contentType ?? "application/json";
     log(`[${this.provider.displayName}] Calling API: ${endpoint}`);
     const requestInit = this.provider.getRequestInit?.() || {};
-    const doFetch = () => fetch(endpoint, {
+    const deadlineAt = tier1DeadlineAt(c);
+    const clamp = deadlineClamp(deadlineAt);
+    const doFetch = () => fetch(endpoint, mergeSignalIntoInit({
       method: "POST",
       headers,
       body: serialized?.body ?? JSON.stringify(requestPayload),
       ...requestInit
-    });
+    }, clamp.signal));
     let response;
     try {
-      response = this.provider.enqueueRequest ? await this.provider.enqueueRequest(doFetch) : await doFetch();
+      try {
+        response = this.provider.enqueueRequest ? await this.provider.enqueueRequest(doFetch) : await doFetch();
+      } finally {
+        clamp.disarm();
+      }
     } catch (error) {
       const conn = classifyConnectionError(error);
-      if (conn) {
-        const msg = buildConnectionErrorMessage(conn.kind, this.provider.displayName, endpoint);
-        log(`[${this.provider.displayName}] ${msg} (code=${conn.code})`);
-        logStderr(`Error: ${msg}`);
-        reportError({
-          error,
-          providerName: this.provider.name,
-          providerDisplayName: this.provider.displayName,
-          streamFormat: this.provider.streamFormat,
-          modelId: this.targetModel,
-          httpStatus: undefined,
-          isStreaming: false,
-          retryAttempted: false,
-          isInteractive: this.isInteractive
-        });
-        try {
-          const { error_class, error_code } = classifyError(error, undefined);
-          recordStats({
-            model_id: this.targetModel,
-            provider_name: this.provider.name,
-            stream_format: this.provider.streamFormat,
-            latency_ms: Math.round(performance.now() - startTime),
-            success: false,
-            http_status: 0,
-            error_class,
-            error_code,
-            token_strategy: this.options.tokenStrategy ?? "standard",
-            adapter_name: this.getActiveAdapterName(),
-            middleware_names: this.middlewareManager.getActiveNames(this.bareModelName),
-            fallback_used: fallbackMeta !== undefined,
-            fallback_chain: fallbackMeta?.chain,
-            fallback_attempts: fallbackMeta?.attempts,
-            invocation_mode: this.options.invocationMode ?? "auto-route"
-          });
-        } catch {}
-        return c.json(wrapAnthropicError(400, msg, "connection_error"), 400);
-      }
-      throw error;
+      if (!conn)
+        throw error;
+      const doFetchWith = (sig) => fetch(endpoint, mergeSignalIntoInit({
+        method: "POST",
+        headers,
+        body: serialized?.body ?? JSON.stringify(requestPayload),
+        ...this.provider.getRequestInit?.() || {}
+      }, sig));
+      const reissue = (sig) => {
+        const attempt = () => doFetchWith(sig);
+        return this.provider.enqueueRequest ? this.provider.enqueueRequest(attempt, { signal: sig }) : attempt();
+      };
+      const outcome = await this.recoverConnection(c, error, conn, endpoint, reissue, {
+        startTime,
+        deadlineAt,
+        fallbackMeta,
+        site: "fetch",
+        recovery: recoveryTally
+      });
+      if (outcome.kind === "respond")
+        return outcome.response;
+      response = outcome.value;
     }
+    if (episodeCount() > 0)
+      noteTargetReachable(this.provider.name, endpoint);
     if (this.provider.getActiveModelName?.()) {
       const activeModel = this.provider.getActiveModelName();
       this.tokenTracker.setActiveModelName(activeModel);
@@ -35874,14 +36866,35 @@ class ComposedHandler {
           log(`[${this.provider.displayName}] Parameter rejected \u2014 retrying: ${recovery.note}`);
           requestPayload = recovery.payload;
           const retrySerialized = this.provider.serializeBody?.(requestPayload);
-          const retryHeaders = await this.provider.getHeaders(payload);
-          retryHeaders["Content-Type"] = retrySerialized?.contentType ?? "application/json";
-          const retryResp = await fetch(endpoint, {
-            method: "POST",
-            headers: retryHeaders,
-            body: retrySerialized?.body ?? JSON.stringify(requestPayload),
-            ...this.provider.getRequestInit?.() || {}
-          });
+          const doParamRetry = async (sig) => {
+            const retryHeaders = await this.provider.getHeaders(payload);
+            retryHeaders["Content-Type"] = retrySerialized?.contentType ?? "application/json";
+            return fetch(endpoint, mergeSignalIntoInit({
+              method: "POST",
+              headers: retryHeaders,
+              body: retrySerialized?.body ?? JSON.stringify(requestPayload),
+              ...this.provider.getRequestInit?.() || {}
+            }, sig));
+          };
+          let retryResp;
+          try {
+            retryResp = await doParamRetry();
+          } catch (err) {
+            const conn = classifyConnectionError(err);
+            if (!conn)
+              throw err;
+            const outcome = await this.recoverConnection(c, err, conn, this.connectionEndpointFor(err, endpoint), doParamRetry, {
+              startTime,
+              deadlineAt: tier1DeadlineAt(c),
+              fallbackMeta,
+              retriedBeforeLadder: true,
+              site: "parameter-recovery",
+              recovery: recoveryTally
+            });
+            if (outcome.kind === "respond")
+              return outcome.response;
+            retryResp = outcome.value;
+          }
           if (retryResp.ok) {
             response = retryResp;
           } else {
@@ -35893,17 +36906,19 @@ class ComposedHandler {
     if (!response.ok) {
       if (response.status === 401 && this.provider.forceRefreshAuth) {
         log(`[${this.provider.displayName}] Got 401, forcing auth refresh and retrying`);
-        try {
+        const doAuthRetry = async (sig) => {
           await this.provider.forceRefreshAuth();
           const retryHeaders = await this.provider.getHeaders(payload);
           retryHeaders["Content-Type"] = serialized?.contentType ?? "application/json";
           const retryInit = this.provider.getRequestInit?.() || {};
-          const retryResp = await fetch(endpoint, {
+          return fetch(endpoint, mergeSignalIntoInit({
             method: "POST",
             headers: retryHeaders,
             body: serialized?.body ?? JSON.stringify(requestPayload),
             ...retryInit
-          });
+          }, sig));
+        };
+        const settleAuthRetry = async (retryResp) => {
           if (retryResp.ok) {
             response = retryResp;
           } else {
@@ -35939,47 +36954,73 @@ class ComposedHandler {
                 fallback_used: fallbackMeta !== undefined,
                 fallback_chain: fallbackMeta?.chain,
                 fallback_attempts: fallbackMeta?.attempts,
-                invocation_mode: this.options.invocationMode ?? "auto-route"
+                invocation_mode: this.options.invocationMode ?? "auto-route",
+                ...this.recoveryStats(recoveryTally)
               });
             } catch {}
             return c.json(wrapAnthropicError(retryResp.status, errorText), retryResp.status);
           }
+          return null;
+        };
+        try {
+          const answered = await settleAuthRetry(await doAuthRetry());
+          if (answered)
+            return answered;
         } catch (err) {
-          log(`[${this.provider.displayName}] Auth refresh failed: ${err.message}`);
-          logStderr(`Error [${this.provider.displayName}]: Authentication failed \u2014 ${err.message}. Check API key.`);
-          reportError({
-            error: err,
-            providerName: this.provider.name,
-            providerDisplayName: this.provider.displayName,
-            streamFormat: this.provider.streamFormat,
-            modelId: this.targetModel,
-            httpStatus: 401,
-            isStreaming: false,
-            retryAttempted: true,
-            isInteractive: this.isInteractive,
-            authType: "oauth"
-          });
-          try {
-            const { error_class, error_code } = classifyError(err, 401, err.message);
-            recordStats({
-              model_id: this.targetModel,
-              provider_name: this.provider.name,
-              stream_format: this.provider.streamFormat,
-              latency_ms: Math.round(performance.now() - startTime),
-              success: false,
-              http_status: 401,
-              error_class,
-              error_code,
-              token_strategy: this.options.tokenStrategy ?? "standard",
-              adapter_name: this.getActiveAdapterName(),
-              middleware_names: this.middlewareManager.getActiveNames(this.bareModelName),
-              fallback_used: fallbackMeta !== undefined,
-              fallback_chain: fallbackMeta?.chain,
-              fallback_attempts: fallbackMeta?.attempts,
-              invocation_mode: this.options.invocationMode ?? "auto-route"
+          const conn = classifyConnectionError(err);
+          if (conn) {
+            const outcome = await this.recoverConnection(c, err, conn, this.connectionEndpointFor(err, endpoint), doAuthRetry, {
+              startTime,
+              deadlineAt: tier1DeadlineAt(c),
+              fallbackMeta,
+              retriedBeforeLadder: true,
+              authType: "oauth",
+              site: "forceRefreshAuth",
+              recovery: recoveryTally
             });
-          } catch {}
-          return c.json(wrapAnthropicError(401, err.message, "authentication_error"), 401);
+            if (outcome.kind === "respond")
+              return outcome.response;
+            const answered = await settleAuthRetry(outcome.value);
+            if (answered)
+              return answered;
+          } else {
+            log(`[${this.provider.displayName}] Auth refresh failed: ${err.message}`);
+            logStderr(`Error [${this.provider.displayName}]: Authentication failed \u2014 ${err.message}. Check API key.`);
+            reportError({
+              error: err,
+              providerName: this.provider.name,
+              providerDisplayName: this.provider.displayName,
+              streamFormat: this.provider.streamFormat,
+              modelId: this.targetModel,
+              httpStatus: 401,
+              isStreaming: false,
+              retryAttempted: true,
+              isInteractive: this.isInteractive,
+              authType: "oauth"
+            });
+            try {
+              const { error_class, error_code } = classifyError(err, 401, err.message);
+              recordStats({
+                model_id: this.targetModel,
+                provider_name: this.provider.name,
+                stream_format: this.provider.streamFormat,
+                latency_ms: Math.round(performance.now() - startTime),
+                success: false,
+                http_status: 401,
+                error_class,
+                error_code,
+                token_strategy: this.options.tokenStrategy ?? "standard",
+                adapter_name: this.getActiveAdapterName(),
+                middleware_names: this.middlewareManager.getActiveNames(this.bareModelName),
+                fallback_used: fallbackMeta !== undefined,
+                fallback_chain: fallbackMeta?.chain,
+                fallback_attempts: fallbackMeta?.attempts,
+                invocation_mode: this.options.invocationMode ?? "auto-route",
+                ...this.recoveryStats(recoveryTally)
+              });
+            } catch {}
+            return c.json(wrapAnthropicError(401, err.message, "authentication_error"), 401);
+          }
         }
       } else {
         const errorText = await response.text();
@@ -36039,7 +37080,8 @@ class ComposedHandler {
             fallback_used: fallbackMeta !== undefined,
             fallback_chain: fallbackMeta?.chain,
             fallback_attempts: fallbackMeta?.attempts,
-            invocation_mode: this.options.invocationMode ?? "auto-route"
+            invocation_mode: this.options.invocationMode ?? "auto-route",
+            ...this.recoveryStats(recoveryTally)
           });
         } catch {}
         const errorBody = parsedErrorBody ?? {
@@ -36083,7 +37125,8 @@ class ComposedHandler {
             fallback_used: fallbackMeta !== undefined,
             fallback_chain: fallbackMeta?.chain,
             fallback_attempts: fallbackMeta?.attempts,
-            invocation_mode: this.options.invocationMode ?? "auto-route"
+            invocation_mode: this.options.invocationMode ?? "auto-route",
+            ...this.recoveryStats(recoveryTally)
           });
         } catch {}
         return c.json(wrapAnthropicError(503, surfaced, "overloaded_error", undefined, settled.message), 503);
@@ -36125,7 +37168,8 @@ class ComposedHandler {
             fallback_used: fallbackMeta !== undefined,
             fallback_chain: fallbackMeta?.chain,
             fallback_attempts: fallbackMeta?.attempts,
-            invocation_mode: this.options.invocationMode ?? "auto-route"
+            invocation_mode: this.options.invocationMode ?? "auto-route",
+            ...this.recoveryStats(recoveryTally)
           });
         } catch {}
         return isTerminal ? c.json(wrapAnthropicError(400, surfaced, "invalid_request_error", undefined, settled.message), 400) : c.json(wrapAnthropicError(503, surfaced, "overloaded_error", undefined, settled.message), 503);
@@ -36156,7 +37200,8 @@ class ComposedHandler {
           fallback_used: fallbackMeta !== undefined,
           fallback_chain: fallbackMeta?.chain,
           fallback_attempts: fallbackMeta?.attempts,
-          invocation_mode: this.options.invocationMode ?? "auto-route"
+          invocation_mode: this.options.invocationMode ?? "auto-route",
+          ...this.recoveryStats(recoveryTally)
         });
       } catch {}
       try {
@@ -36501,6 +37546,9 @@ var init_composed_handler = __esm(() => {
   init_middleware();
   init_provider_definitions();
   init_openai();
+  init_clock();
+  init_coordinator();
+  init_settings();
   init_vision_proxy();
   init_session_events();
   init_pro_injection();
@@ -36522,6 +37570,7 @@ var init_composed_handler = __esm(() => {
   init_openai_responses_sse();
   init_openai_sse();
   init_token_tracker();
+  init_transient_retry();
   init_upstream_error_capture();
   STREAM_RETRY_DELAYS_MS = [3000, 15000, 30000];
 });
@@ -37085,6 +38134,7 @@ var init_openai_codex = __esm(() => {
   init_model_catalog();
   init_authority();
   init_billing_probe();
+  init_connection_error();
   init_conversation_key();
   init_openai();
   OpenAICodexTransport = class OpenAICodexTransport extends OpenAIProviderTransport {
@@ -37092,7 +38142,9 @@ var init_openai_codex = __esm(() => {
     async refreshAuth() {
       try {
         this.cachedAuth = await credentials.getRequestAuth("openai-codex", { model: "" });
-      } catch {
+      } catch (err) {
+        if (classifyConnectionError(err))
+          throw err;
         this.cachedAuth = null;
       }
       const signedWithOAuth = this.cachedAuth?.arm === "oauth";
@@ -37381,7 +38433,7 @@ class VertexProviderTransport {
     try {
       this.cachedAuth = await credentials.getRequestAuth("vertex", { model: this.parsed.model });
     } catch (e) {
-      throw new Error(`Vertex AI auth failed: ${e.message}`);
+      throw new Error(`Vertex AI auth failed: ${e.message}`, { cause: e });
     }
   }
   async forceRefreshAuth() {
@@ -41849,46 +42901,6 @@ var init_stream_json_reducer = __esm(() => {
   };
 });
 
-// src/config.ts
-var DEFAULT_PORT_RANGE, ENV;
-var init_config2 = __esm(() => {
-  DEFAULT_PORT_RANGE = { start: 3000, end: 9000 };
-  ENV = {
-    OPENROUTER_API_KEY: "OPENROUTER_API_KEY",
-    CLAUDISH_MODEL: "CLAUDISH_MODEL",
-    CLAUDISH_PORT: "CLAUDISH_PORT",
-    CLAUDISH_ACTIVE_MODEL_NAME: "CLAUDISH_ACTIVE_MODEL_NAME",
-    CLAUDISH_TOKEN_FILE: "CLAUDISH_TOKEN_FILE",
-    CLAUDISH_PROVIDER_NAME: "CLAUDISH_PROVIDER_NAME",
-    ANTHROPIC_MODEL: "ANTHROPIC_MODEL",
-    ANTHROPIC_SMALL_FAST_MODEL: "ANTHROPIC_SMALL_FAST_MODEL",
-    CLAUDISH_MODEL_OPUS: "CLAUDISH_MODEL_OPUS",
-    CLAUDISH_MODEL_SONNET: "CLAUDISH_MODEL_SONNET",
-    CLAUDISH_MODEL_HAIKU: "CLAUDISH_MODEL_HAIKU",
-    CLAUDISH_MODEL_SUBAGENT: "CLAUDISH_MODEL_SUBAGENT",
-    ANTHROPIC_DEFAULT_OPUS_MODEL: "ANTHROPIC_DEFAULT_OPUS_MODEL",
-    ANTHROPIC_DEFAULT_SONNET_MODEL: "ANTHROPIC_DEFAULT_SONNET_MODEL",
-    ANTHROPIC_DEFAULT_HAIKU_MODEL: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
-    CLAUDE_CODE_SUBAGENT_MODEL: "CLAUDE_CODE_SUBAGENT_MODEL",
-    CLAUDE_CODE_AUTO_COMPACT_WINDOW: "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
-    CLAUDE_CODE_MAX_CONTEXT_TOKENS: "CLAUDE_CODE_MAX_CONTEXT_TOKENS",
-    OLLAMA_BASE_URL: "OLLAMA_BASE_URL",
-    OLLAMA_HOST: "OLLAMA_HOST",
-    LMSTUDIO_BASE_URL: "LMSTUDIO_BASE_URL",
-    VLLM_BASE_URL: "VLLM_BASE_URL",
-    GEMINI_API_KEY: "GEMINI_API_KEY",
-    GEMINI_BASE_URL: "GEMINI_BASE_URL",
-    OPENAI_API_KEY: "OPENAI_API_KEY",
-    OPENAI_BASE_URL: "OPENAI_BASE_URL",
-    CLAUDISH_SUMMARIZE_TOOLS: "CLAUDISH_SUMMARIZE_TOOLS",
-    CLAUDISH_DIAG_MODE: "CLAUDISH_DIAG_MODE",
-    CLAUDISH_DEBUG: "CLAUDISH_DEBUG",
-    CLAUDISH_ANTHROPIC_API_BILLING: "CLAUDISH_ANTHROPIC_API_BILLING",
-    CLAUDISH_CLASSIFIER_PROVIDER: "CLAUDISH_CLASSIFIER_PROVIDER",
-    CLAUDISH_CLASSIFIER_MODEL: "CLAUDISH_CLASSIFIER_MODEL"
-  };
-});
-
 // src/process-tree.ts
 function signalProcessTree(proc, signal) {
   if (KILL_PROCESS_GROUP && proc.pid) {
@@ -43323,7 +44335,7 @@ var TEAM_CAPTURE_ENV_VAR = "CLAUDISH_TEAM_CAPTURE", liveTeamRuns, STDOUT_TAIL_LI
 var init_team_orchestrator = __esm(() => {
   init_prehydrate();
   init_stream_json_reducer();
-  init_config2();
+  init_config();
   init_upstream_error_capture();
   init_process_tree();
   init_redact();
@@ -43337,7 +44349,7 @@ var init_team_orchestrator = __esm(() => {
 
 // src/channel/session-manager.ts
 import { spawn as spawn3 } from "child_process";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import {
   appendFileSync as appendFileSync6,
   closeSync as closeSync7,
@@ -43493,8 +44505,8 @@ class SessionManager {
     if (opts.sessionId !== undefined && this.sessions.has(opts.sessionId)) {
       throw new Error(`Session id already in use: ${opts.sessionId}`);
     }
-    const sessionId = opts.sessionId ?? randomUUID4().slice(0, 8);
-    const claudeSessionId = randomUUID4();
+    const sessionId = opts.sessionId ?? randomUUID5().slice(0, 8);
+    const claudeSessionId = randomUUID5();
     const timeout = Math.min(opts.timeoutSeconds ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     const startedAt = new Date().toISOString();
     const sessionDir = opts.sessionDir ?? join31(this.sessionsDir, sessionId);
@@ -44224,7 +45236,7 @@ ${STDERR_TRUNCATION_MARKER} ${STDERR_SIDE_LIMIT} bytes per end \u2026
 }
 var DEFAULT_MAX_SESSIONS = 20, DRAIN_TIMEOUT_MS = 1e4, DEFAULT_SCROLLBACK = 2000, DEFAULT_TIMEOUT = 600, MAX_TIMEOUT = 3600, KILL_GRACE_MS = 5000, TERMINAL_RETENTION_MS, MAX_TERMINAL_SESSIONS = 50, STDERR_SIDE_LIMIT, EVENT_LOG_LIMIT, EVENT_RING_SIZE = 200, EVENT_PREVIEW_CHARS = 800, DEFAULT_EVENT_LIMIT = 40, UPSTREAM_ERROR_TAIL_BYTES, STDERR_TRUNCATION_MARKER = "[claudish] \u2026 stderr truncated to", TERMINAL_STATUSES, KNOWN_STATUSES, SESSION_ID_RE, META_READ_LIMIT, OUTPUT_TAIL_BYTES, STDERR_READ_BYTES, EVENT_TAIL_BYTES, NO_TERMINAL_RECORD = "claudish_no_terminal_record", RESERVED_FLAG_ALIASES, TRANSPORT_BREAKING_FLAGS, RESERVED_CHILD_FLAGS, metaString = (v) => typeof v === "string" && v.length > 0 ? v : null, metaNumber = (v) => typeof v === "number" && Number.isFinite(v) ? v : null, metaStatus = (v) => typeof v === "string" && KNOWN_STATUSES.includes(v) ? v : null, CLAUDISH_NOTE_PREFIX = "[claudish] ";
 var init_session_manager = __esm(() => {
-  init_config2();
+  init_config();
   init_upstream_error_capture();
   init_process_tree();
   init_redact();
@@ -44849,7 +45861,8 @@ async function probeLink(proxyUrl, link, timeoutMs) {
     response = await fetch(`${proxyUrl}/v1/messages`, {
       method: "POST",
       headers: {
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
+        "x-claudish-no-recovery": "1"
       },
       body: JSON.stringify({
         model: link.modelSpec,
@@ -48774,8 +49787,12 @@ class FallbackHandler {
           }
           return response;
         }
+        if (isRecoveryHoldResponse(response)) {
+          logStderr(`[Fallback] ${name} is unreachable and claudish is still retrying it \u2014 ` + "holding the chain here rather than switching providers mid-outage.");
+          return response;
+        }
         const errorBody = await response.clone().text();
-        if (!isRetryableError(response.status, errorBody, name)) {
+        if (!isRetryableError(response.status, errorBody, name, response.headers)) {
           if (errors.length > 0) {
             errors.push({ provider: name, status: response.status, message: errorBody });
             return this.formatCombinedError(c, errors, payload.model);
@@ -48824,7 +49841,9 @@ ${summary}`);
     }
   }
 }
-function isRetryableError(status, errorBody, provider) {
+function isRetryableError(status, errorBody, provider, headers) {
+  if (isClaudishConnectionVerdict(headers))
+    return false;
   if (hasQuotaExhaustionWording(errorBody))
     return true;
   const upstream = status === 400 ? extractUpstreamStatus(errorBody) : undefined;
@@ -49071,6 +50090,14 @@ var init_native_handler = __esm(() => {
 });
 
 // src/handlers/shared/local-queue.ts
+function toAbortError(reason) {
+  if (reason instanceof Error)
+    return reason;
+  const err = new Error("Request aborted while queued");
+  err.name = "AbortError";
+  return err;
+}
+
 class LocalModelQueue {
   static instance = null;
   queue = [];
@@ -49101,7 +50128,10 @@ class LocalModelQueue {
       return true;
     return enabled !== "false" && enabled !== "0";
   }
-  async enqueue(fetchFn, providerId, concurrencyOverride) {
+  async enqueue(fetchFn, providerId, concurrencyOverride, signal) {
+    if (signal?.aborted) {
+      throw toAbortError(signal.reason);
+    }
     if (concurrencyOverride !== undefined) {
       if (concurrencyOverride === 0) {
         if (getLogLevel() === "debug") {
@@ -49128,8 +50158,22 @@ class LocalModelQueue {
         fetchFn,
         resolve,
         reject,
-        providerId
+        providerId,
+        signal
       };
+      if (signal) {
+        const onAbort = () => {
+          queuedRequest.abandoned = true;
+          queuedRequest.detach?.();
+          queuedRequest.detach = undefined;
+          const i = this.queue.indexOf(queuedRequest);
+          if (i !== -1)
+            this.queue.splice(i, 1);
+          reject(toAbortError(signal.reason));
+        };
+        queuedRequest.detach = () => signal.removeEventListener("abort", onAbort);
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
       this.queue.push(queuedRequest);
       if (getLogLevel() === "debug") {
         log(`[LocalQueue] Request enqueued for ${providerId} (queue length: ${this.queue.length}, active: ${this.activeRequests}/${this.maxParallel})`);
@@ -49142,6 +50186,11 @@ class LocalModelQueue {
       const request = this.queue.shift();
       if (!request)
         break;
+      if (request.abandoned || request.signal?.aborted) {
+        request.detach?.();
+        request.detach = undefined;
+        continue;
+      }
       if (getLogLevel() === "debug") {
         log(`[LocalQueue] Processing request for ${request.providerId} (${this.queue.length} remaining in queue, ${this.activeRequests + 1}/${this.maxParallel} active)`);
       }
@@ -49155,6 +50204,8 @@ class LocalModelQueue {
   }
   async executeRequest(request) {
     this.activeRequests++;
+    request.detach?.();
+    request.detach = undefined;
     try {
       const response = await request.fetchFn();
       if (response.status === 500) {
@@ -49250,6 +50301,8 @@ class LocalTransport {
   concurrency;
   healthChecked = false;
   isHealthy = false;
+  lastProbeError;
+  lastProbeUrl;
   _contextWindow = 32768;
   constructor(config, modelName, options) {
     this.config = config;
@@ -49317,17 +50370,19 @@ class LocalTransport {
     }
     return {};
   }
-  async enqueueRequest(fetchFn) {
+  async enqueueRequest(fetchFn, opts) {
     if (!LocalModelQueue.isEnabled())
       return fetchFn();
-    return LocalModelQueue.getInstance().enqueue(fetchFn, this.name, this.concurrency);
+    return LocalModelQueue.getInstance().enqueue(fetchFn, this.name, this.concurrency, opts?.signal);
   }
   async refreshAuth() {
     if (this.healthChecked)
       return;
     const healthy = await this.checkHealth();
     if (!healthy) {
-      throw new Error(this.getConnectionErrorMessage());
+      throw Object.assign(new Error(this.getConnectionErrorMessage(), {
+        cause: this.lastProbeError
+      }), { claudishEndpoint: this.lastProbeUrl ?? this.config.baseUrl });
     }
     await this.fetchContextWindow();
   }
@@ -49340,8 +50395,10 @@ class LocalTransport {
   async checkHealth() {
     if (this.healthChecked)
       return this.isHealthy;
+    this.lastProbeError = undefined;
+    this.lastProbeUrl = undefined;
+    const healthUrl = `${this.config.baseUrl}/api/tags`;
     try {
-      const healthUrl = `${this.config.baseUrl}/api/tags`;
       log(`[${this.displayName}] Trying health check: ${healthUrl}`);
       const response = await fetch(healthUrl, {
         method: "GET",
@@ -49355,10 +50412,12 @@ class LocalTransport {
       }
       log(`[${this.displayName}] /api/tags returned ${response.status}, trying /v1/models`);
     } catch (e) {
+      this.lastProbeError = markOwnTimeout(e);
+      this.lastProbeUrl = healthUrl;
       log(`[${this.displayName}] /api/tags failed: ${e?.message || e}, trying /v1/models`);
     }
+    const modelsUrl = `${this.config.baseUrl}/v1/models`;
     try {
-      const modelsUrl = `${this.config.baseUrl}/v1/models`;
       log(`[${this.displayName}] Trying health check: ${modelsUrl}`);
       const response = await fetch(modelsUrl, {
         method: "GET",
@@ -49372,9 +50431,10 @@ class LocalTransport {
       }
       log(`[${this.displayName}] /v1/models returned ${response.status}`);
     } catch (e) {
+      this.lastProbeError = markOwnTimeout(e);
+      this.lastProbeUrl = modelsUrl;
       log(`[${this.displayName}] /v1/models failed: ${e?.message || e}`);
     }
-    this.healthChecked = true;
     this.isHealthy = false;
     log(`[${this.displayName}] Health check FAILED - provider not available`);
     return false;
@@ -49467,6 +50527,7 @@ class LocalTransport {
 var localProviderAgent, DISPLAY_NAMES2;
 var init_local = __esm(() => {
   init_authority();
+  init_connection_error();
   init_local_queue();
   init_logger();
   init_probe_discovery();
@@ -50337,6 +51398,7 @@ ${plan.hint}` : `[Route] ${plan.reason}`;
     modelRequestCount: () => modelRequestCount,
     shutdown: async () => {
       await server.stop(true);
+      closeAllEpisodes();
     },
     invalidateHandlerCache: (providerSlug) => {
       if (!providerSlug) {
@@ -50389,6 +51451,7 @@ var init_proxy_server = __esm(() => {
   init_local();
   init_openrouter();
   init_poe();
+  init_coordinator();
   init_pricing_cache();
   RoutingError = class RoutingError extends Error {
     constructor(message) {
@@ -52322,14 +53385,57 @@ var init_behavior_command = __esm(() => {
   init_ansi();
 });
 
+// src/launcher/magmux-binary.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync27 } from "fs";
+import { dirname as dirname11, join as join36 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function findMagmuxBinaryOrNull() {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = dirname11(thisFile);
+  const pkgRoots = [join36(thisDir, ".."), join36(thisDir, "..", "..")];
+  const platform = process.platform;
+  const arch = process.arch;
+  for (const pkgRoot of pkgRoots) {
+    const bundled = join36(pkgRoot, "native", `magmux-${platform}-${arch}`);
+    if (existsSync27(bundled))
+      return bundled;
+  }
+  try {
+    const pkgName = `@claudish/magmux-${platform}-${arch}`;
+    let searchDir = pkgRoots[0];
+    for (let i = 0;i < 5; i++) {
+      const candidate = join36(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync27(candidate))
+        return candidate;
+      const parent = dirname11(searchDir);
+      if (parent === searchDir)
+        break;
+      searchDir = parent;
+    }
+  } catch {}
+  try {
+    const result = execSync("which magmux", { encoding: "utf-8" }).trim();
+    if (result)
+      return result;
+  } catch {}
+  return null;
+}
+function findMagmuxBinary() {
+  const found = findMagmuxBinaryOrNull();
+  if (found)
+    return found;
+  throw new Error(`magmux not found. Install it:
+  brew install MadAppGang/tap/magmux`);
+}
+var init_magmux_binary = () => {};
+
 // src/team-grid.ts
 import { spawn as spawn4 } from "child_process";
-import { execSync } from "child_process";
-import { existsSync as existsSync27, readFileSync as readFileSync28, writeFileSync as writeFileSync17 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync28, writeFileSync as writeFileSync17 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname11, join as join36 } from "path";
+import { join as join37 } from "path";
 import { setTimeout as wait } from "timers/promises";
-import { fileURLToPath as fileURLToPath2 } from "url";
 function resolveRouteInfo(modelId) {
   const parsed = parseModelSpec(modelId);
   if (parsed.isExplicitProvider) {
@@ -52418,36 +53524,6 @@ function buildPaneHeader(model, prompt, bg) {
   lines.push(`printf '\\033[2m  %s\\033[0m\\n\\n' '\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500';`);
   return lines.join(" ");
 }
-function findMagmuxBinary() {
-  const thisFile = fileURLToPath2(import.meta.url);
-  const thisDir = dirname11(thisFile);
-  const pkgRoot = join36(thisDir, "..");
-  const platform = process.platform;
-  const arch = process.arch;
-  const bundledMagmux = join36(pkgRoot, "native", `magmux-${platform}-${arch}`);
-  if (existsSync27(bundledMagmux))
-    return bundledMagmux;
-  try {
-    const pkgName = `@claudish/magmux-${platform}-${arch}`;
-    let searchDir = pkgRoot;
-    for (let i = 0;i < 5; i++) {
-      const candidate = join36(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync27(candidate))
-        return candidate;
-      const parent = dirname11(searchDir);
-      if (parent === searchDir)
-        break;
-      searchDir = parent;
-    }
-  } catch {}
-  try {
-    const result = execSync("which magmux", { encoding: "utf-8" }).trim();
-    if (result)
-      return result;
-  } catch {}
-  throw new Error(`magmux not found. Install it:
-  brew install MadAppGang/tap/magmux`);
-}
 function withoutControlPanes(evt) {
   if (!Array.isArray(evt.panes))
     return evt;
@@ -52456,7 +53532,7 @@ function withoutControlPanes(evt) {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync27(sockPath)) {
+    if (existsSync28(sockPath)) {
       try {
         client = await new Promise((resolve, reject) => {
           const s = netConnect(sockPath);
@@ -52543,9 +53619,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join36(sessionPath, "gridfile.txt");
-  const prompt = readFileSync28(join36(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync28(join36(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join37(sessionPath, "gridfile.txt");
+  const prompt = readFileSync28(join37(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync28(join37(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -52576,12 +53652,13 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join36(sessionPath, "status.json");
+  const statusPath = join37(sessionPath, "status.json");
   writeFileSync17(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
 var BANNER_BG_COLORS;
 var init_team_grid = __esm(() => {
+  init_magmux_binary();
   init_profile_config();
   init_model_parser();
   init_routing_rules();
@@ -52598,7 +53675,7 @@ var init_team_grid = __esm(() => {
 
 // src/team-cli.ts
 import { readFileSync as readFileSync29 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 function getFlag(args, flag) {
   const idx = args.indexOf(flag);
   if (idx === -1 || idx + 1 >= args.length)
@@ -52721,7 +53798,7 @@ async function teamCommand(args) {
     }
     case "judge": {
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync29(join37(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync29(join38(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "run-and-judge": {
@@ -52738,7 +53815,7 @@ async function teamCommand(args) {
       });
       printStatus(status);
       await judgeResponses(sessionPath, { judges });
-      console.log(readFileSync29(join37(sessionPath, "verdict.md"), "utf-8"));
+      console.log(readFileSync29(join38(sessionPath, "verdict.md"), "utf-8"));
       break;
     }
     case "status": {
@@ -55578,9 +56655,9 @@ var init_keychain_command = __esm(() => {
 
 // src/auth/antigravity-oauth.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync28, unlinkSync as unlinkSync6 } from "fs";
+import { existsSync as existsSync29, unlinkSync as unlinkSync6 } from "fs";
 import { homedir as homedir33 } from "os";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -55701,8 +56778,8 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join38(homedir33(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
-      if (existsSync28(tokenFile))
+      const tokenFile = join39(homedir33(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      if (existsSync29(tokenFile))
         unlinkSync6(tokenFile);
     } catch {}
     log("[AntigravityOAuth] Antigravity session cleared (keychain + agy token file)");
@@ -57211,9 +58288,9 @@ var init_DiscoveryNotice = __esm(() => {
 });
 
 // src/providers/model-descriptions.ts
-import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync30, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync17, readFileSync as readFileSync30, writeFileSync as writeFileSync18 } from "fs";
 import { homedir as homedir34 } from "os";
-import { dirname as dirname12, join as join39 } from "path";
+import { dirname as dirname12, join as join40 } from "path";
 function emptyDescriptionIndex() {
   return EMPTY_INDEX;
 }
@@ -57232,7 +58309,7 @@ function indexFrom(cache) {
   };
 }
 function readCache(path) {
-  if (!existsSync29(path))
+  if (!existsSync30(path))
     return null;
   try {
     const raw = JSON.parse(readFileSync30(path, "utf-8"));
@@ -57306,7 +58383,7 @@ var init_model_descriptions = __esm(() => {
   init_logger();
   init_model_loader();
   init_cache_ttl();
-  MODEL_DESCRIPTIONS_CACHE_PATH = join39(homedir34(), ".claudish", "model-descriptions.json");
+  MODEL_DESCRIPTIONS_CACHE_PATH = join40(homedir34(), ".claudish", "model-descriptions.json");
   EMPTY_INDEX = { get: () => {
     return;
   }, size: 0 };
@@ -62462,30 +63539,30 @@ var init_branding = __esm(() => {
 });
 
 // src/update-checker.ts
-import { existsSync as existsSync30, mkdirSync as mkdirSync18, readFileSync as readFileSync31, unlinkSync as unlinkSync7, writeFileSync as writeFileSync19 } from "fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync31, unlinkSync as unlinkSync7, writeFileSync as writeFileSync19 } from "fs";
 import { homedir as homedir35, platform as platform2, tmpdir } from "os";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join40(homedir35(), "AppData", "Local");
-    cacheDir = join40(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join41(homedir35(), "AppData", "Local");
+    cacheDir = join41(localAppData, "claudish");
   } else {
-    cacheDir = join40(homedir35(), ".cache", "claudish");
+    cacheDir = join41(homedir35(), ".cache", "claudish");
   }
   try {
-    if (!existsSync30(cacheDir)) {
+    if (!existsSync31(cacheDir)) {
       mkdirSync18(cacheDir, { recursive: true });
     }
-    return join40(cacheDir, "update-check.json");
+    return join41(cacheDir, "update-check.json");
   } catch {
-    return join40(tmpdir(), "claudish-update-check.json");
+    return join41(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache2() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync30(cachePath)) {
+    if (!existsSync31(cachePath)) {
       return null;
     }
     const data = JSON.parse(readFileSync31(cachePath, "utf-8"));
@@ -62511,7 +63588,7 @@ function isCacheValid(cache) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync30(cachePath)) {
+    if (existsSync31(cachePath)) {
       unlinkSync7(cachePath);
     }
   } catch {}
@@ -62596,7 +63673,7 @@ var init_update_checker = __esm(() => {
 // src/cli.ts
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync31,
+  existsSync as existsSync32,
   mkdirSync as mkdirSync19,
   readFileSync as readFileSync32,
   readdirSync as readdirSync7,
@@ -62604,14 +63681,14 @@ import {
   writeFileSync as writeFileSync20
 } from "fs";
 import { homedir as homedir36 } from "os";
-import { dirname as dirname13, join as join41 } from "path";
+import { dirname as dirname13, join as join42 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join41(homedir36(), ".claudish");
-  if (!existsSync31(cacheDir))
+  const cacheDir = join42(homedir36(), ".claudish");
+  if (!existsSync32(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -62619,7 +63696,7 @@ function clearAllModelCaches() {
     const files = readdirSync7(cacheDir);
     for (const file of files) {
       if (cachePatterns.includes(file)) {
-        unlinkSync8(join41(cacheDir, file));
+        unlinkSync8(join42(cacheDir, file));
         cleared++;
       }
     }
@@ -62774,6 +63851,10 @@ async function parseArgs(args) {
       if (config.logLevel === "info") {
         config.logLevel = "debug";
       }
+    } else if (arg === "--recovery-ui" || arg === "--no-recovery-ui") {
+      setRecoveryFlagOverrides({ recoveryUi: arg === "--recovery-ui" });
+    } else if (arg === "--recovery" || arg === "--no-recovery") {
+      setRecoveryFlagOverrides({ recovery: arg === "--recovery" });
     } else if (arg === "--no-debug-claudish") {
       config.debug = false;
     } else if (arg === "--log-debug") {
@@ -63093,8 +64174,8 @@ Usage:  claudish --models --provider <slug>`);
     });
     config.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config.quiet) {
-      const markerFile = join41(homedir36(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync31(markerFile)) {
+      const markerFile = join42(homedir36(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync32(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
@@ -64302,7 +65383,7 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join41(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guidePath = join42(__dirname3, "../AI_AGENT_GUIDE.md");
     const guideContent = readFileSync32(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error) {
@@ -64319,19 +65400,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join41(cwd, ".claude");
-  const skillsDir = join41(claudeDir, "skills");
-  const claudishSkillDir = join41(skillsDir, "claudish-usage");
-  const skillFile = join41(claudishSkillDir, "SKILL.md");
-  if (existsSync31(skillFile)) {
+  const claudeDir = join42(cwd, ".claude");
+  const skillsDir = join42(claudeDir, "skills");
+  const claudishSkillDir = join42(skillsDir, "claudish-usage");
+  const skillFile = join42(claudishSkillDir, "SKILL.md");
+  if (existsSync32(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join41(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync31(sourceSkillPath)) {
+  const sourceSkillPath = join42(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync32(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -64340,15 +65421,15 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync31(claudeDir)) {
+    if (!existsSync32(claudeDir)) {
       mkdirSync19(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync31(skillsDir)) {
+    if (!existsSync32(skillsDir)) {
       mkdirSync19(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync31(claudishSkillDir)) {
+    if (!existsSync32(claudishSkillDir)) {
       mkdirSync19(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
@@ -64407,7 +65488,7 @@ function printAvailableModels() {
 var __filename3, __dirname3;
 var init_cli = __esm(() => {
   init_base_api_format();
-  init_config2();
+  init_config();
   init_logger();
   init_model_loader();
   init_model_selector();
@@ -64425,6 +65506,7 @@ var init_cli = __esm(() => {
   init_provider_definitions();
   init_provider_slug_resolve();
   init_routing_rules();
+  init_settings();
   init_ansi();
   init_provider_resolver();
   __filename3 = fileURLToPath3(import.meta.url);
@@ -71760,12 +72842,592 @@ var init_tui = __esm(() => {
   }
 });
 
+// src/launcher/magmux-wrapper.ts
+import {
+  chmodSync,
+  closeSync as closeSync8,
+  existsSync as existsSync33,
+  mkdirSync as mkdirSync20,
+  mkdtempSync,
+  openSync as openSync8,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync21
+} from "fs";
+import { connect as netConnect2 } from "net";
+import { join as join43 } from "path";
+function envDeltas(parentEnv, childEnv) {
+  const set = [];
+  const unset = [];
+  for (const [k, v] of Object.entries(childEnv)) {
+    if (STRIPPED_CHILD_VARS.includes(k))
+      continue;
+    if (parentEnv[k] !== v)
+      set.push([k, v]);
+  }
+  for (const k of Object.keys(parentEnv)) {
+    if (!(k in childEnv))
+      unset.push(k);
+  }
+  for (const k of STRIPPED_CHILD_VARS) {
+    if (!unset.includes(k))
+      unset.push(k);
+  }
+  return { set, unset };
+}
+function shq(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function buildLauncherScript(claudeBinary, claudeArgs, deltas) {
+  const lines = [
+    "#!/bin/sh",
+    "# Generated by claudish. Re-asserts claudish's OWN environment deltas after",
+    "# the login shell has run the user's profile, then hands the terminal to",
+    "# Claude Code. Only deltas are written here: the full environment would put",
+    "# every exported secret into a file."
+  ];
+  for (const k of deltas.unset)
+    lines.push(`unset ${k}`);
+  for (const [k, v] of deltas.set)
+    lines.push(`export ${k}=${shq(v)}`);
+  lines.push(`exec ${shq(claudeBinary)} ${claudeArgs.map(shq).join(" ")}`);
+  return `${lines.join(`
+`)}
+`;
+}
+function magmuxPaneCapability(input) {
+  const parentEnv = input.parentEnv ?? process.env;
+  if (!input.interactive)
+    return { kind: "none", reason: "not-interactive" };
+  const ambient = parentEnv.MAGMUX_SOCK;
+  if (ambient)
+    return { kind: "ambient", sock: ambient };
+  if (!input.stdoutIsTty)
+    return { kind: "none", reason: "no-tty" };
+  const magmux = input.magmuxBinary === undefined ? findMagmuxBinaryOrNull() : input.magmuxBinary;
+  if (!magmux)
+    return { kind: "none", reason: "no-magmux" };
+  return { kind: "wrap", magmux };
+}
+function planMagmuxWrap(input) {
+  const capability = magmuxPaneCapability(input);
+  if (capability.kind !== "wrap")
+    return null;
+  const magmux = capability.magmux;
+  const pid = input.pid ?? process.pid;
+  const id = `claudish-${pid}`;
+  const controlSocket = `/tmp/magmux-${id}.sock`;
+  const tmpRoot = input.tmpRoot ?? "/tmp";
+  mkdirSync20(tmpRoot, { recursive: true });
+  const scriptDir = mkdtempSync(join43(tmpRoot, "claudish-launch-"));
+  chmodSync(scriptDir, 448);
+  const scriptPath = join43(scriptDir, "claude-launch.sh");
+  const parentEnv = input.parentEnv ?? process.env;
+  const deltas = envDeltas(parentEnv, input.childEnv);
+  const fd = openSync8(scriptPath, "wx", 384);
+  try {
+    writeFileSync21(fd, buildLauncherScript(input.claudeBinary, input.claudeArgs, deltas));
+  } finally {
+    closeSync8(fd);
+  }
+  const env = { ...input.childEnv };
+  for (const k of STRIPPED_CHILD_VARS)
+    delete env[k];
+  if (!env.MAGMUX_SCROLLBACK)
+    env.MAGMUX_SCROLLBACK = "10000";
+  const args = [
+    "--id",
+    id,
+    "--no-idle-done",
+    "-w",
+    "--no-status",
+    "-e",
+    `. ${shq(scriptPath)}`
+  ];
+  let paneExit = null;
+  const exitListeners = [];
+  let control = null;
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned)
+      return;
+    cleaned = true;
+    process.removeListener("exit", cleanup);
+    try {
+      control?.destroy();
+    } catch {}
+    control = null;
+    try {
+      rmSync2(scriptDir, { recursive: true, force: true });
+    } catch {}
+    try {
+      if (existsSync33(controlSocket))
+        rmSync2(controlSocket, { force: true });
+    } catch {}
+  };
+  process.on("exit", cleanup);
+  return {
+    command: magmux,
+    args,
+    env,
+    controlSocket,
+    scriptPath,
+    paneExitCode: () => paneExit,
+    onClaudeExit(fn) {
+      exitListeners.push(fn);
+    },
+    watch(proc) {
+      let stopped = false;
+      const attempt = async () => {
+        for (let i = 0;i < 60 && !stopped; i++) {
+          if (existsSync33(controlSocket)) {
+            try {
+              const s = await new Promise((resolve, reject) => {
+                const sock = netConnect2(controlSocket);
+                sock.once("connect", () => resolve(sock));
+                sock.once("error", reject);
+              });
+              control = s;
+              let buf = "";
+              s.on("data", (chunk) => {
+                buf += chunk.toString("utf-8");
+                let nl = buf.indexOf(`
+`);
+                while (nl >= 0) {
+                  const line = buf.slice(0, nl).trim();
+                  buf = buf.slice(nl + 1);
+                  nl = buf.indexOf(`
+`);
+                  if (!line)
+                    continue;
+                  try {
+                    const evt = JSON.parse(line);
+                    if (evt.type === "exit" && evt.pane === 0) {
+                      paneExit = typeof evt.exitCode === "number" ? evt.exitCode : null;
+                      for (const fn of exitListeners)
+                        fn(paneExit);
+                    }
+                  } catch {}
+                }
+              });
+              s.on("error", () => {
+                control = null;
+              });
+              return;
+            } catch {}
+          }
+          await new Promise((r) => setTimeout(r, 50));
+        }
+      };
+      proc.once("exit", () => {
+        stopped = true;
+        cleanup();
+      });
+      attempt();
+    },
+    cleanup
+  };
+}
+var STRIPPED_CHILD_VARS;
+var init_magmux_wrapper = __esm(() => {
+  init_magmux_binary();
+  STRIPPED_CHILD_VARS = ["CLAUDECODE", "CLAUDE_CODE_CHILD_SESSION"];
+});
+
+// src/recovery/types.ts
+var UI_LEASE_MS = 1e4, FRAME_TICK_MS = 1000;
+
+// src/recovery/magmux-ui.ts
+import { execFile as execFile2 } from "child_process";
+import { existsSync as existsSync34 } from "fs";
+import { connect as netConnect3 } from "net";
+import { promisify as promisify5 } from "util";
+function resolveControlEndpoint() {
+  if (explicitControlSock && existsSync34(explicitControlSock)) {
+    return { sock: explicitControlSock, wrapped: true };
+  }
+  const ambient = process.env.MAGMUX_SOCK;
+  if (ambient && existsSync34(ambient))
+    return { sock: ambient, wrapped: false };
+  return null;
+}
+function noteUnavailable(message) {
+  if (state.unavailableLogged)
+    return;
+  state.unavailableLogged = true;
+  log(message);
+}
+function uiLeaseValid2(episodeId) {
+  if (!state.control || state.targetPane === null)
+    return false;
+  const last = state.leases.get(episodeId);
+  if (last === undefined)
+    return false;
+  return recoveryClock().now() - last < UI_LEASE_MS;
+}
+async function connectControl(sock) {
+  try {
+    return await new Promise((resolve, reject) => {
+      const s = netConnect3(sock);
+      s.once("connect", () => resolve(s));
+      s.once("error", reject);
+    });
+  } catch {
+    return null;
+  }
+}
+function request(socket, msg, timeoutMs = CONTROL_TIMEOUT_MS) {
+  const id = state.nextControlId++;
+  return new Promise((resolve) => {
+    let buf = "";
+    let settled = false;
+    const finish = (v) => {
+      if (settled)
+        return;
+      settled = true;
+      socket.removeListener("data", onData);
+      clearTimeout(timer);
+      resolve(v);
+    };
+    const onData = (chunk) => {
+      buf += chunk.toString("utf-8");
+      let nl = buf.indexOf(`
+`);
+      while (nl >= 0) {
+        const line = buf.slice(0, nl).trim();
+        buf = buf.slice(nl + 1);
+        nl = buf.indexOf(`
+`);
+        if (!line)
+          continue;
+        try {
+          const evt = JSON.parse(line);
+          if (evt.type === "reply" && evt.id === id)
+            finish(evt);
+        } catch {}
+      }
+    };
+    const timer = setTimeout(() => finish(null), timeoutMs);
+    timer.unref?.();
+    socket.on("data", onData);
+    try {
+      socket.write(`${JSON.stringify({ ...msg, id })}
+`);
+    } catch {
+      finish(null);
+    }
+  });
+}
+function dropConnection() {
+  state.control = null;
+  state.targetPane = null;
+  state.leases.clear();
+}
+async function ancestorPids(maxDepth = 6) {
+  const out = new Set([process.pid]);
+  let pid = process.ppid;
+  for (let i = 0;i < maxDepth && pid > 1; i++) {
+    out.add(pid);
+    try {
+      const { stdout } = await execFileAsync("ps", ["-o", "ppid=", "-p", String(pid)], {
+        timeout: 1000
+      });
+      const next = Number(stdout.trim());
+      if (!Number.isFinite(next) || next <= 1)
+        break;
+      pid = next;
+    } catch {
+      break;
+    }
+  }
+  return out;
+}
+async function findOwnPane(socket) {
+  const reply = await request(socket, { type: "list" });
+  const result = reply?.result;
+  const panes = Array.isArray(result) ? result : Array.isArray(result?.panes) ? result.panes : [];
+  const ancestors = await ancestorPids();
+  for (const p of panes) {
+    const pane = p.pane;
+    const pid = p.pid;
+    if (typeof pane === "number" && typeof pid === "number" && ancestors.has(pid))
+      return pane;
+  }
+  return null;
+}
+function ensureConnected() {
+  if (state.control && state.targetPane !== null)
+    return Promise.resolve(true);
+  if (state.paneNotFound)
+    return Promise.resolve(false);
+  if (state.connecting)
+    return state.connecting;
+  state.connecting = (async () => {
+    const endpoint = resolveControlEndpoint();
+    if (!endpoint) {
+      noteUnavailable("[Recovery] no magmux control endpoint \u2014 no banner; recovery continues without one");
+      return false;
+    }
+    const socket = await connectControl(endpoint.sock);
+    if (!socket) {
+      noteUnavailable(`[Recovery] could not reach magmux at ${endpoint.sock} \u2014 no banner`);
+      return false;
+    }
+    const onGone = () => {
+      if (state.control === socket)
+        dropConnection();
+    };
+    socket.on("error", onGone);
+    socket.on("close", onGone);
+    state.control = socket;
+    const pane = endpoint.wrapped ? 0 : await findOwnPane(socket);
+    if (pane === null) {
+      state.paneNotFound = true;
+      log("[Recovery] this claudish's pane was not found in magmux \u2014 no banner");
+      try {
+        socket.end();
+      } catch {}
+      dropConnection();
+      return false;
+    }
+    state.targetPane = pane;
+    state.unavailableLogged = false;
+    log(`[Recovery] banner will draw on magmux pane ${pane} ` + `(${endpoint.wrapped ? "magmux launched by claudish" : "ambient magmux"})`);
+    return true;
+  })().finally(() => {
+    state.connecting = null;
+  });
+  return state.connecting;
+}
+function formatElapsed2(ms) {
+  const s = Math.max(0, Math.round(ms / 1000));
+  if (s < 60)
+    return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60)
+    return `${m}m ${String(s % 60).padStart(2, "0")}s`;
+  return `${Math.floor(m / 60)}h ${m % 60}m`;
+}
+function wrap(text, cols) {
+  const out = [];
+  let line = "";
+  for (const word of text.split(/\s+/).filter(Boolean)) {
+    if (line && line.length + 1 + word.length > cols) {
+      out.push(line);
+      line = word;
+    } else {
+      line = line ? `${line} ${word}` : word;
+    }
+  }
+  if (line)
+    out.push(line);
+  return out;
+}
+function bannerText(frame, nowMs) {
+  const lines = [`\u2717 NETWORK \xB7 ${frame.providerDisplayName} ${KIND_WORD[frame.kind]}`];
+  lines.push(...wrap(frame.reason, OVERLAY_WRAP_COLS));
+  lines.push(`${frame.host} \xB7 ${frame.code ?? frame.kind}${frame.loopback ? " \xB7 local" : ""}`);
+  const elapsed = formatElapsed2(nowMs - frame.startedAtMs);
+  const attempt = Math.max(1, frame.attempts);
+  if (frame.state === "handoff") {
+    lines.push(`handed back to Claude Code \xB7 waiting for its retry \xB7 ${elapsed} in recovery`);
+  } else if (frame.nextAttemptAtMs === null) {
+    lines.push(`connecting to ${frame.host}\u2026 \xB7 attempt ${attempt} \xB7 ${elapsed} in recovery`);
+  } else {
+    const secs = Math.max(0, Math.ceil((frame.nextAttemptAtMs - nowMs) / 1000));
+    lines.push(`next attempt in ${secs}s \xB7 attempt ${attempt} \xB7 ${elapsed} in recovery`);
+  }
+  const counts = [];
+  if (frame.waiters > 0)
+    counts.push(`${frame.waiters} request${frame.waiters === 1 ? "" : "s"} held`);
+  if (frame.otherEpisodes > 0) {
+    counts.push(`+${frame.otherEpisodes} more outage${frame.otherEpisodes === 1 ? "" : "s"}`);
+  }
+  if (counts.length > 0)
+    lines.push(counts.join(" \xB7 "));
+  lines.push("Esc in Claude Code stops the turn");
+  return lines.join(`
+`);
+}
+function recoveredText(frame, nowMs) {
+  return [
+    `\u2713 NETWORK \xB7 ${frame.providerDisplayName} recovered`,
+    `${frame.attempts} attempt${frame.attempts === 1 ? "" : "s"} over ${formatElapsed2(nowMs - frame.startedAtMs)}`
+  ].join(`
+`);
+}
+async function paint2(frame) {
+  if (state.painting)
+    return;
+  state.painting = true;
+  try {
+    if (!await ensureConnected())
+      return;
+    const socket = state.control;
+    const pane = state.targetPane;
+    if (!socket || pane === null)
+      return;
+    const reply = await request(socket, {
+      type: "overlay",
+      pane,
+      text: bannerText(frame, Date.now()),
+      style: "error"
+    });
+    const ok = reply?.ok === true;
+    if (ok && !episodeIsLive(frame.episodeId)) {
+      state.lastPaintOk = ok;
+      return;
+    }
+    if (ok) {
+      const first = !state.leases.has(frame.episodeId);
+      state.leases.set(frame.episodeId, recoveryClock().now());
+      state.lastFrame = frame;
+      if (first) {
+        log(`[Recovery] banner painted for episode ${frame.episodeId} on magmux pane ${pane} ` + "\u2014 lease granted");
+      }
+      request(socket, { type: "tint", pane, color: "red" });
+    } else if (state.lastPaintOk !== false) {
+      log(`[Recovery] magmux did not acknowledge the banner: ${JSON.stringify(reply)}`);
+    }
+    state.lastPaintOk = ok;
+  } finally {
+    state.painting = false;
+  }
+}
+async function writeOverlay(text, style, tint) {
+  const socket = state.control;
+  const pane = state.targetPane;
+  if (!socket || pane === null)
+    return;
+  await request(socket, { type: "overlay", pane, text, style });
+  await request(socket, { type: "tint", pane, color: tint });
+}
+function clearOverlay() {
+  return writeOverlay("", "", "reset");
+}
+function stopTick() {
+  if (state.tickTimer !== null) {
+    recoveryClock().clearTimeout(state.tickTimer);
+    state.tickTimer = null;
+  }
+}
+function cancelLinger() {
+  if (state.lingerTimer !== null) {
+    recoveryClock().clearTimeout(state.lingerTimer);
+    state.lingerTimer = null;
+  }
+}
+function startTick() {
+  if (state.tickTimer !== null)
+    return;
+  const clock = recoveryClock();
+  const loop = () => {
+    state.tickTimer = null;
+    const frame = renderableEpisodeFrame();
+    if (!frame)
+      return;
+    paint2(frame);
+    const t = clock.setTimeout(loop, FRAME_TICK_MS);
+    clock.unref?.(t);
+    state.tickTimer = t;
+  };
+  loop();
+}
+function onEpisodeOpened(episodeId) {
+  markPaneRequested(episodeId);
+  cancelLinger();
+  startTick();
+}
+function onEpisodeClosed(episodeId, outcome, attempts) {
+  state.leases.delete(episodeId);
+  if (renderableEpisodeFrame() !== null)
+    return;
+  stopTick();
+  const last = state.lastFrame?.episodeId === episodeId ? state.lastFrame : null;
+  state.lastFrame = null;
+  if (outcome !== "recovered" || !last) {
+    clearOverlay();
+    return;
+  }
+  writeOverlay(recoveredText({ ...last, attempts }, Date.now()), "success", "green");
+  cancelLinger();
+  const clock = recoveryClock();
+  const timer = clock.setTimeout(() => {
+    state.lingerTimer = null;
+    if (renderableEpisodeFrame() !== null)
+      return;
+    clearOverlay();
+  }, OUTCOME_LINGER_MS);
+  clock.unref?.(timer);
+  state.lingerTimer = timer;
+}
+function installRecoveryUi(controlSock) {
+  explicitControlSock = controlSock;
+  if (installed)
+    return;
+  installed = true;
+  registerRecoveryUi(hooks);
+}
+async function shutdownRecoveryUi() {
+  stopTick();
+  cancelLinger();
+  if (state.control && state.targetPane !== null) {
+    const socket = state.control;
+    const pane = state.targetPane;
+    await request(socket, { type: "overlay", pane, text: "", style: "" }, 500);
+    await request(socket, { type: "tint", pane, color: "reset" }, 500);
+  }
+  if (state.control) {
+    try {
+      state.control.end();
+    } catch {}
+  }
+  dropConnection();
+  state.lastFrame = null;
+  state.lastPaintOk = null;
+  state.unavailableLogged = false;
+  state.paneNotFound = false;
+  registerRecoveryUi(null);
+  installed = false;
+  explicitControlSock = null;
+}
+var execFileAsync, OUTCOME_LINGER_MS = 4000, OVERLAY_WRAP_COLS = 60, CONTROL_TIMEOUT_MS = 3000, explicitControlSock = null, state, installed = false, KIND_WORD, hooks;
+var init_magmux_ui = __esm(() => {
+  init_logger();
+  init_clock();
+  init_coordinator();
+  execFileAsync = promisify5(execFile2);
+  state = {
+    control: null,
+    connecting: null,
+    targetPane: null,
+    leases: new Map,
+    lastFrame: null,
+    tickTimer: null,
+    lingerTimer: null,
+    painting: false,
+    lastPaintOk: null,
+    unavailableLogged: false,
+    paneNotFound: false,
+    nextControlId: 1
+  };
+  KIND_WORD = {
+    refused: "refused",
+    dns: "not found",
+    unreachable: "unreachable"
+  };
+  hooks = {
+    onEpisodeOpened,
+    onEpisodeClosed,
+    leaseValid: (episodeId) => uiLeaseValid2(episodeId)
+  };
+});
+
 // src/terminal-isolation.ts
 import { format } from "util";
 function beginTerminalIsolation(onSuppressed) {
-  if (active)
+  if (active2)
     return () => {};
-  active = true;
+  active2 = true;
   const emit = (source, text) => {
     if (routing)
       return;
@@ -71795,17 +73457,17 @@ function beginTerminalIsolation(onSuppressed) {
   process.stdout.write = makeWrite("stdout");
   process.stderr.write = makeWrite("stderr");
   return function restore() {
-    if (!active)
+    if (!active2)
       return;
     for (const method of CONSOLE_METHODS) {
       console[method] = originalConsole[method];
     }
     process.stdout.write = originalStdoutWrite;
     process.stderr.write = originalStderrWrite;
-    active = false;
+    active2 = false;
   };
 }
-var CONSOLE_METHODS, active = false, routing = false;
+var CONSOLE_METHODS, active2 = false, routing = false;
 var init_terminal_isolation = __esm(() => {
   CONSOLE_METHODS = ["log", "error", "warn", "info", "debug", "trace", "dir"];
 });
@@ -71813,18 +73475,18 @@ var init_terminal_isolation = __esm(() => {
 // src/claude-runner.ts
 import { spawn as spawn5, spawnSync as spawnSync4 } from "child_process";
 import {
-  closeSync as closeSync8,
-  existsSync as existsSync32,
-  mkdirSync as mkdirSync20,
-  openSync as openSync8,
+  closeSync as closeSync9,
+  existsSync as existsSync35,
+  mkdirSync as mkdirSync21,
+  openSync as openSync9,
   readFileSync as readFileSync33,
   readdirSync as readdirSync8,
   statSync as statSync8,
   unlinkSync as unlinkSync9,
-  writeFileSync as writeFileSync21
+  writeFileSync as writeFileSync22
 } from "fs";
 import { homedir as homedir37, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname14, join as join42 } from "path";
+import { dirname as dirname14, join as join44 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -71884,12 +73546,12 @@ function isRealAnthropicEnvCredential(env, name) {
 }
 function hasResolvableAnthropicAuth(deps = {}) {
   const env = deps.env ?? process.env;
-  const fileExists = deps.fileExists ?? existsSync32;
+  const fileExists = deps.fileExists ?? existsSync35;
   const keychainProbe = deps.keychainProbe ?? defaultKeychainAnthropicProbe;
   if (isRealAnthropicEnvCredential(env, "ANTHROPIC_API_KEY") || isRealAnthropicEnvCredential(env, "ANTHROPIC_AUTH_TOKEN")) {
     return true;
   }
-  if (fileExists(join42(homedir37(), ".claude", ".credentials.json")))
+  if (fileExists(join44(homedir37(), ".claude", ".credentials.json")))
     return true;
   return keychainProbe();
 }
@@ -71904,7 +73566,7 @@ function isProxyAuthMode(config) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join42(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join44(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
@@ -71925,9 +73587,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join42(homeDir, ".claudish");
+  const claudishDir = join44(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join42(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join44(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const light = getThemeMode() === "light";
   const cyanCode = light ? "38;2;14;116;144" : "96";
@@ -72060,13 +73722,13 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync21(scriptPath, script, "utf-8");
+  writeFileSync22(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync20(dirname14(tokenFilePath), { recursive: true });
-    writeFileSync21(tokenFilePath, JSON.stringify({
+    mkdirSync21(dirname14(tokenFilePath), { recursive: true });
+    writeFileSync22(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
       total_tokens: 0,
@@ -72097,7 +73759,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join42(dir, name);
+    const full = join44(dir, name);
     try {
       if (statSync8(full).mtimeMs >= cutoff)
         continue;
@@ -72126,13 +73788,13 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join42(homedir37(), ".claude", "settings.json"),
-    join42(cwd, ".claude", "settings.json"),
-    join42(cwd, ".claude", "settings.local.json")
+    join44(homedir37(), ".claude", "settings.json"),
+    join44(cwd, ".claude", "settings.json"),
+    join44(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
-  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync32(file));
+  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync35(file));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
@@ -72169,13 +73831,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join42(homeDir, ".claudish");
+  const claudishDir = join44(homeDir, ".claudish");
   try {
-    mkdirSync20(claudishDir, { recursive: true });
+    mkdirSync21(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join42(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join42(claudishDir, `tokens-${port}.json`);
+  const tempPath = join44(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join44(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -72209,7 +73871,7 @@ function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLi
     padding: 0
   };
   const settings = buildClaudishSettingsOverlay(statusLine, proxyAuthMode);
-  writeFileSync21(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync22(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine, tokenFilePath };
 }
 function buildClaudishSettingsOverlay(statusLine, proxyAuthMode) {
@@ -72234,7 +73896,7 @@ function mergeUserSettingsIfPresent(config, tempSettingsPath, statusLine, proxyA
     if (proxyAuthMode && !("forceLoginMethod" in userSettings)) {
       userSettings.forceLoginMethod = "console";
     }
-    writeFileSync21(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync22(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -72305,13 +73967,13 @@ function resolveAdvisorToolEnv(config, processEnv = process.env) {
   return { vars: { [ADVISOR_TOOL_ENV_VAR]: "1" }, source: "claudish" };
 }
 function discoverUserAdvisorModel(claudeArgs = [], cwd = process.cwd()) {
-  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync32(file));
+  const sources = userSettingsFileCandidates(cwd).filter((file) => existsSync35(file));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
     sources.push(settingsArg);
   const managed = managedSettingsPath();
-  if (existsSync32(managed))
+  if (existsSync35(managed))
     sources.push(managed);
   let effective;
   for (const source of sources) {
@@ -72434,6 +74096,11 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
     [ENV.CLAUDISH_TOKEN_FILE]: tokenFilePath,
     ...advisorToolEnv.vars
   };
+  const paneCapability = magmuxPaneCapability({
+    interactive: Boolean(config.interactive),
+    stdoutIsTty: Boolean(process.stdout.isTTY)
+  });
+  applyRetryWatchdog(env, { paneEligible: paneCapability.kind !== "none" });
   if (modelId) {
     const parsedSpec = parseModelSpec(modelId);
     const providerDisplayName = parsedSpec.isExplicitProvider ? getProviderByName(parsedSpec.provider)?.displayName : undefined;
@@ -72526,7 +74193,7 @@ async function runClaudeWithProxy(config, proxyUrl, onCleanup) {
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
     const home = homedir37();
-    const localPath = isWindows2() ? join42(home, ".claude", "local", "claude.exe") : join42(home, ".claude", "local", "claude");
+    const localPath = isWindows2() ? join44(home, ".claude", "local", "claude.exe") : join44(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -72537,11 +74204,11 @@ Or set CLAUDE_PATH to your custom installation:`);
   const childWantsTty = config.interactive && !process.stdout.isTTY && Boolean(process.stdin.isTTY);
   if (childWantsTty) {
     try {
-      const fd = openSync8("/dev/fd/0", "r+");
+      const fd = openSync9("/dev/fd/0", "r+");
       if (isatty(fd)) {
         ttyFd = fd;
       } else {
-        closeSync8(fd);
+        closeSync9(fd);
       }
     } catch {
       ttyFd = undefined;
@@ -72551,11 +74218,29 @@ Or set CLAUDE_PATH to your custom installation:`);
   }
   const filterChildStderr = !config.interactive && ttyFd === undefined;
   const stdio = ttyFd !== undefined ? [0, ttyFd, ttyFd] : filterChildStderr ? ["inherit", "inherit", "pipe"] : "inherit";
-  const proc = spawn5(spawnCommand, claudeArgs, {
+  const wrap = recoverySurfaceAllowed() && paneCapability.kind === "wrap" ? planMagmuxWrap({
+    claudeBinary,
+    claudeArgs,
+    childEnv: env,
+    cwd: process.cwd(),
+    interactive: Boolean(config.interactive),
+    stdoutIsTty: Boolean(process.stdout.isTTY),
+    magmuxBinary: paneCapability.magmux
+  }) : null;
+  const proc = wrap ? spawn5(wrap.command, wrap.args, { env: wrap.env, stdio, shell: false }) : spawn5(spawnCommand, claudeArgs, {
     env,
     stdio,
     shell: needsShell
   });
+  if (wrap) {
+    wrap.watch(proc);
+    installRecoveryUi(wrap.controlSocket);
+    wrap.onClaudeExit(() => {
+      shutdownRecoveryUi();
+    });
+  } else if (recoverySurfaceAllowed() && config.interactive && process.env.MAGMUX_SOCK) {
+    installRecoveryUi(null);
+  }
   if (filterChildStderr && proc.stderr) {
     relayChildStderr(proc.stderr);
   }
@@ -72568,7 +74253,7 @@ Or set CLAUDE_PATH to your custom installation:`);
     const fdToClose = ttyFd;
     proc.on("spawn", () => {
       try {
-        closeSync8(fdToClose);
+        closeSync9(fdToClose);
       } catch {}
     });
   }
@@ -72576,12 +74261,14 @@ Or set CLAUDE_PATH to your custom installation:`);
   const { exitCode, exitSignal } = await new Promise((resolve) => {
     proc.on("exit", (code, signal) => {
       setClaudeCodeRunning(false);
+      const paneExit = wrap?.paneExitCode() ?? null;
       resolve({
-        exitCode: signal ? 128 + (SIGNAL_EXIT_NUMBERS[signal] ?? 0) : code ?? 1,
+        exitCode: paneExit !== null ? paneExit : signal ? 128 + (SIGNAL_EXIT_NUMBERS[signal] ?? 0) : code ?? 1,
         exitSignal: signal
       });
     });
   });
+  wrap?.cleanup();
   log(exitSignal ? `[Claude Code] Exited from ${exitSignal} (exit code ${exitCode})` : `[Claude Code] Exited with code ${exitCode}`);
   releaseTerminalIsolation();
   try {
@@ -72614,23 +74301,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync32(process.env.CLAUDE_PATH)) {
+    if (existsSync35(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
   const home = homedir37();
-  const localPath = isWindows ? join42(home, ".claude", "local", "claude.exe") : join42(home, ".claude", "local", "claude");
-  if (existsSync32(localPath)) {
+  const localPath = isWindows ? join44(home, ".claude", "local", "claude.exe") : join44(home, ".claude", "local", "claude");
+  if (existsSync35(localPath)) {
     return localPath;
   }
   if (isWindows) {
     const windowsPaths = [
-      join42(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join42(home, ".npm-global", "claude.cmd"),
-      join42(home, "node_modules", ".bin", "claude.cmd")
+      join44(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join44(home, ".npm-global", "claude.cmd"),
+      join44(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path of windowsPaths) {
-      if (existsSync32(path)) {
+      if (existsSync35(path)) {
         return path;
       }
     }
@@ -72638,14 +74325,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join42(home, ".npm-global/bin/claude"),
-      join42(home, ".local/bin/claude"),
-      join42(home, "node_modules/.bin/claude"),
+      join44(home, ".npm-global/bin/claude"),
+      join44(home, ".local/bin/claude"),
+      join44(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join42(home, "../usr/bin/claude")
+      join44(home, "../usr/bin/claude")
     ];
     for (const path of commonPaths) {
-      if (existsSync32(path)) {
+      if (existsSync35(path)) {
         return path;
       }
     }
@@ -72699,13 +74386,16 @@ var restoreTerminal = null, macosKeychainAnthropicResult, defaultKeychainAnthrop
 }, 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", CHILD_STDERR_NOISE, SIGNAL_EXIT_NUMBERS;
 var init_claude_runner = __esm(() => {
   init_model_catalog();
-  init_config2();
+  init_config();
+  init_magmux_wrapper();
   init_logger();
   init_profile_config();
   init_model_discovery();
   init_model_parser();
   init_provider_definitions();
   init_routing_rules();
+  init_magmux_ui();
+  init_settings();
   init_telemetry();
   init_terminal_isolation();
   init_theme_mode();
@@ -72720,18 +74410,18 @@ var init_claude_runner = __esm(() => {
 });
 
 // src/diag-output.ts
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync21, unlinkSync as unlinkSync10, writeFileSync as writeFileSync22 } from "fs";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync22, unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir38 } from "os";
-import { join as join43 } from "path";
+import { join as join45 } from "path";
 function getClaudishDir() {
-  const dir = join43(homedir38(), ".claudish");
+  const dir = join45(homedir38(), ".claudish");
   try {
-    mkdirSync21(dir, { recursive: true });
+    mkdirSync22(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join43(getClaudishDir(), `diag-${process.pid}.log`);
+  return join45(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -72740,7 +74430,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync22(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync23(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -73221,7 +74911,7 @@ var init_advisor_startup = __esm(() => {
 });
 
 // src/session/conversation.ts
-import { closeSync as closeSync9, openSync as openSync9, readSync as readSync4, statSync as statSync9 } from "fs";
+import { closeSync as closeSync10, openSync as openSync10, readSync as readSync4, statSync as statSync9 } from "fs";
 import { StringDecoder as StringDecoder3 } from "string_decoder";
 function looksLikeTurn(line) {
   const assistant = line.includes('"type":"assistant"');
@@ -73277,7 +74967,7 @@ function readConversation(file, opts = {}) {
   let fd = null;
   try {
     const size = statSync9(file).size;
-    fd = openSync9(file, "r");
+    fd = openSync10(file, "r");
     const buf = Buffer.allocUnsafe(chunkBytes);
     const decoder = new StringDecoder3("utf-8");
     let pending = "";
@@ -73333,7 +75023,7 @@ function readConversation(file, opts = {}) {
   } catch {} finally {
     if (fd !== null) {
       try {
-        closeSync9(fd);
+        closeSync10(fd);
       } catch {}
     }
   }
@@ -74937,9 +76627,9 @@ __export(exports_session_stats, {
 });
 import { readFileSync as readFileSync34 } from "fs";
 import { homedir as homedir39 } from "os";
-import { join as join44 } from "path";
+import { join as join46 } from "path";
 function tokenFilePath(port) {
-  return process.env.CLAUDISH_TOKEN_FILE || join44(homedir39(), ".claudish", `tokens-${port}.json`);
+  return process.env.CLAUDISH_TOKEN_FILE || join46(homedir39(), ".claudish", `tokens-${port}.json`);
 }
 function readSessionStats(port, opts) {
   let raw;
@@ -75024,7 +76714,7 @@ function bg(hex) {
   const [r, g, b] = rgb(hex);
   return `\x1B[48;2;${r};${g};${b}m`;
 }
-function paint2(text, hex, bold = false) {
+function paint3(text, hex, bold = false) {
   return `${bold ? BOLD4 : ""}${fg(hex)}${text}${RESET3}`;
 }
 function meter(pct, width, ramp = ramps.load) {
@@ -75032,7 +76722,7 @@ function meter(pct, width, ramp = ramps.load) {
   if (!Number.isFinite(cells) || cells <= 0)
     return "";
   if (Number.isNaN(pct))
-    return paint2(NODATA2.repeat(cells), tokens.dead);
+    return paint3(NODATA2.repeat(cells), tokens.dead);
   const cols = rampFor(cells, ramp);
   const filled = fillCells(pct, cells);
   let out = "";
@@ -75053,7 +76743,7 @@ function stackedBar(segments, width) {
     return "";
   const split = splitCells(segments.map((s) => s.value), cells);
   if (split.reduce((a, b) => a + b, 0) === 0)
-    return paint2(TRACK2.repeat(cells), tokens.border);
+    return paint3(TRACK2.repeat(cells), tokens.border);
   let out = "";
   for (let i = 0;i < split.length; i++) {
     const n = split[i];
@@ -75178,14 +76868,14 @@ function renderSessionSummary(input) {
   const W = cardWidth();
   const inner = W - CHROME;
   const out = [];
-  const dim = (s) => paint2(s, tokens.subtle);
-  const body = (s) => paint2(s, tokens.text);
+  const dim = (s) => paint3(s, tokens.subtle);
+  const body = (s) => paint3(s, tokens.text);
   const titleText = exitCode === 0 ? " session " : " session \xB7 failed ";
   const titleHex = exitCode === 0 ? tokens.accent : tokens.error;
   const rule = "\u2500".repeat(Math.max(0, W - 2 - visibleWidth(titleText) - 1));
-  out.push(paint2("\u256D\u2500", tokens.border) + paint2(titleText, titleHex) + paint2(rule + "\u256E", tokens.border));
+  out.push(paint3("\u256D\u2500", tokens.border) + paint3(titleText, titleHex) + paint3(rule + "\u256E", tokens.border));
   const row = (s) => {
-    out.push(`${paint2("\u2502", tokens.border)} ${padVisible2(s, inner)} ${paint2("\u2502", tokens.border)}`);
+    out.push(`${paint3("\u2502", tokens.border)} ${padVisible2(s, inner)} ${paint3("\u2502", tokens.border)}`);
   };
   const blank = () => row("");
   const chips = [badge(truncate2(modelSpec, 34), tokens.accent)];
@@ -75235,13 +76925,13 @@ function renderSessionSummary(input) {
     if (rest > 0)
       segs.push({ value: rest, color: area(other) });
     dataRow("tools", stackedBar(segs, barW), body(padStartTo(String(stats.toolCallTotal), 4)) + dim(" calls"));
-    const legend = shown.map((t, i) => paint2(`${t.name} ${t.count}`, toolCols[i])).concat(rest > 0 ? [paint2(`other ${rest}`, other)] : []);
+    const legend = shown.map((t, i) => paint3(`${t.name} ${t.count}`, toolCols[i])).concat(rest > 0 ? [paint3(`other ${rest}`, other)] : []);
     for (const line of wrapStyled(legend, dim(" \xB7 "), inner - LABEL_W)) {
       row(" ".repeat(LABEL_W) + line);
     }
   }
   blank();
-  row(dim(padTo("cost", LABEL_W)) + paint2(stats.isFree ? "free" : usd(stats.costUsd), tokens.text, true) + (stats.isEstimated && !stats.isFree ? dim("  estimated") : ""));
+  row(dim(padTo("cost", LABEL_W)) + paint3(stats.isFree ? "free" : usd(stats.costUsd), tokens.text, true) + (stats.isEstimated && !stats.isFree ? dim("  estimated") : ""));
   const dearest = Math.max(0, ...stats.savings.map((s) => s.baselineUsd));
   for (const s of stats.savings) {
     const label = padTo(`vs ${s.label}`, LABEL_W);
@@ -75250,10 +76940,10 @@ function renderSessionSummary(input) {
       const share = dearest > 0 ? s.savedUsd / dearest * 100 : 0;
       dataRow(label, meter(share, barW, areaRamp(ramps.volume)), dim(`${padStartTo(`${Math.round(pct)}%`, 4)} saved `) + body(usd(s.savedUsd)));
     } else {
-      dataRow(label, meter(0, barW, areaRamp(ramps.volume)), dim("over by ") + paint2(usd(-s.savedUsd), tokens.error));
+      dataRow(label, meter(0, barW, areaRamp(ramps.volume)), dim("over by ") + paint3(usd(-s.savedUsd), tokens.error));
     }
   }
-  out.push(paint2(`\u2570${"\u2500".repeat(W - 2)}\u256F`, tokens.border));
+  out.push(paint3(`\u2570${"\u2500".repeat(W - 2)}\u256F`, tokens.border));
   if (resumeId) {
     out.push("");
     out.push(dim("Resume this session with:"));
@@ -75302,8 +76992,8 @@ init_op_source();
 init_startup_trace();
 init_picker_cancelled();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync33, readFileSync as readFileSync35 } from "fs";
-import { join as join45, resolve as resolve6 } from "path";
+import { existsSync as existsSync36, readFileSync as readFileSync35 } from "fs";
+import { join as join47, resolve as resolve6 } from "path";
 
 // src/tui/runtime/should-open-picker.ts
 function noModelConfigured(gate) {
@@ -75416,7 +77106,7 @@ async function applyConfigOverride() {
   await Promise.resolve();
   const plan = planConfigOverride(process.argv.slice(2), process.env, {
     resolve: resolve6,
-    exists: existsSync33
+    exists: existsSync36
   });
   if (plan.kind === "none")
     return;
@@ -75558,7 +77248,7 @@ async function runCli() {
   const endImports = beginSpan("startup:cli-imports");
   await Promise.resolve().then(() => init_claude_runner());
   await Promise.resolve().then(() => init_cli());
-  await Promise.resolve().then(() => init_config2());
+  await Promise.resolve().then(() => init_config());
   await Promise.resolve().then(() => init_model_selector());
   await Promise.resolve().then(() => init_provider_resolver());
   await Promise.resolve().then(() => init_logger());
@@ -75596,7 +77286,7 @@ async function runCli() {
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join45(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join47(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         await Promise.resolve().then(() => init_team_orchestrator());
         setupSession(sessionPath, cliConfig.team, prompt);
@@ -75605,7 +77295,7 @@ async function runCli() {
         });
         const result = { ...status, responses: {} };
         for (const anonId of Object.keys(status.models)) {
-          const responsePath = join45(sessionPath, `response-${anonId}.md`);
+          const responsePath = join47(sessionPath, `response-${anonId}.md`);
           try {
             const raw = readFileSync35(responsePath, "utf-8").trim();
             try {