@rikcodes/teamclaude 1.1.20-rik.14 → 1.1.20-rik.15

package/README.md

@@ -107,10 +107,12 @@ A Claude Code session can use OpenAI models alongside the Claude accounts. They
 **1. Install the sidecar and log it into your ChatGPT account** (one time):
 
 ```bash
-brew install raine/claude-code-proxy/claude-code-proxy
+curl -fsSL https://raw.githubusercontent.com/rikbrown/claude-code-proxy/rik/main/scripts/install.sh | bash
 claude-code-proxy codex auth login
 ```
 
+This installs [rikbrown/claude-code-proxy](https://github.com/rikbrown/claude-code-proxy), a fork of the reference sidecar. Take the fork rather than upstream's Homebrew build: it forwards Codex's quota headers, without which every bar on the account reads `unknown`, and it lets you raise the 60-second header timeout that otherwise kills a long reasoning turn. See [Timeouts](docs/openai.md#timeouts).
+
 **2. Connect it** — add four pieces to `~/.config/teamclaude.json`:
 
 ```json
@@ -161,11 +163,11 @@ Each request is routed by the model name in its body, so one session can freely
 
 1. Check that your sidecar build lists it: `curl -s http://127.0.0.1:18765/v1/models`. The sidecar has its own allow-list and rejects any id that it does not know, regardless of the TeamClaude configuration. Upgrade the sidecar if the id is missing.
 2. Add a `customModels` row. Codex publishes the window for each model as `context_window` in `~/.codex/models_cache.json`; copy it to `contextTokens`.
-3. Start a new `teamclaude run` session. The rows are read at launch, so you do not need to restart the server. If you upgraded the sidecar binary, restart the server — or send `SIGTERM` to the sidecar process and let the supervisor restart it with the new binary.
+3. Start a new `teamclaude run` session. The rows are read at launch, so you do not need to restart the server. If you upgraded the sidecar binary, restart the server — or send `SIGTERM` to the sidecar process and let the supervisor restart it with the new binary. The first `SIGTERM` only starts a graceful shutdown, which a request in flight holds open; send it a second time to force the exit.
 
-Claude Code prints one `[claude-code:unrecognized_model]` line to stderr for each custom model. This is expected; suppressing it would lose the correct context window. The quota bars for the sidecar account show `unknown` unless the sidecar forwards Codex's rate-limit headers — see [Quota](docs/openai.md#quota). Keep the sidecar on loopback.
+Claude Code prints one `[claude-code:unrecognized_model]` line to stderr for each custom model. This is expected; suppressing it would lose the correct context window. The quota bars for the sidecar account show `unknown` unless the sidecar forwards Codex's rate-limit headers, which the fork build in step 1 does and upstream's does not — see [Quota](docs/openai.md#quota). Keep the sidecar on loopback.
 
-The sidecar appears under the account table as a `⚙` line rather than a row because it holds no subscription, is the only account its route can use, and never rotates. The line also shows its supervised process state (`up pid 98018`, or `down (code 1) 3 restarts`).
+The sidecar appears under the account table as a `⚙` line rather than a row because it holds no subscription, is the only account its route can use, and never rotates. The line also shows its supervised process state (`up pid 98018`, or `down (code 1) 3 restarts`), followed by what the sidecar reports about itself while it is up (`2 active 3 errors`, read from its own `/monitor` endpoint; each is omitted at zero, and both are omitted if that endpoint does not answer).
 
 #### Several ChatGPT accounts
 
@@ -221,7 +223,7 @@ Three details matter:
 - **`CCP_CODEX_TRANSPORT=http` is required.** A WebSocket upgrade is relayed with the caller's own headers and draws no account, so the WebSocket transport cannot be pooled.
 - **Do not reuse a name across providers.** Routes address accounts by name, so a shared name admits both — including the Claude account that cannot serve `gpt-*`, which outranks the sidecar on priority and wins. TeamClaude warns at startup when it sees one.
 
-Two things differ from the single-account setup: each turn appears **twice** in the activity list, once per hop, and tokens are booked against the sidecar account, so a ChatGPT account reads `N req · 0 tok`. Its quota bars are unaffected because they come from the `x-codex-*` headers on the second hop, where the subscription is.
+One thing differs from the single-account setup: each turn appears **twice** in the activity list, once per hop. Tokens and quota bars both come from the second hop, where the subscription is, so they are booked against the ChatGPT account that served. The sidecar account holds a stub login and spends nothing of its own, so it reads `N req · 0 tok` — booking it as well would double every figure.
 
 Full details, including what happens to quota on each hop: [Several ChatGPT accounts behind one sidecar](docs/openai.md#several-chatgpt-accounts-behind-one-sidecar).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rikcodes/teamclaude",
-  "version": "1.1.20-rik.14",
+  "version": "1.1.20-rik.15",
   "description": "Multi-account proxy for Claude Code and Codex: pools Claude Max, ChatGPT/Codex, API-key and third-party backend accounts, and rotates on quota",
   "type": "module",
   "main": "src/index.js",

package/src/account-manager.js

@@ -3492,7 +3492,9 @@ export class AccountManager {
     // threshold and every request fails, while a sibling sits at 0%.
     // A standalone sidecar (no Codex accounts here) is NOT a conduit: it holds
     // its own login, the forwarded numbers are its own, and they still apply.
-    if (!(isLocalUpstream(account) && this.accounts.some(a => providerOf(a) === 'codex'))) {
+    // Shares its definition with the token counters, which drop a conduit hop
+    // for the same reason: what it reports belongs to whoever served.
+    if (!this._isCodexConduit(account)) {
       for (const window of ['primary', 'secondary']) {
         const used = parseFloat(headers[`x-codex-${window}-used-percent`]);
         const minutes = parseInt(headers[`x-codex-${window}-window-minutes`], 10);
@@ -3563,12 +3565,49 @@ export class AccountManager {
     }
   }
 
+  /**
+   * Whether `account` merely RELAYS to this fleet's own Codex pool instead of
+   * holding a subscription of its own: a translating sidecar whose back leg is
+   * pointed back at this proxy, so each turn crosses this process twice — once
+   * inbound on `/v1/messages` and once outbound on `/backend-api/codex/*`
+   * (docs/openai.md, "Several ChatGPT accounts behind one sidecar").
+   *
+   * Keyed on three things, all of which the documented setup has and no other
+   * account does:
+   *
+   *   a loopback upstream   the sidecar runs on this machine.
+   *   the Anthropic wire    a conduit is reached on `/v1/messages`, so it
+   *                         carries no `provider` field — docs/openai.md warns
+   *                         that giving one `"provider": "codex"` puts it in the
+   *                         foreign-subscription partition and every `gpt-*`
+   *                         request then fails to find an account. A pooled
+   *                         ChatGPT account is therefore never a conduit,
+   *                         whatever its upstream says; it IS the pool.
+   *   a pool to relay to    a standalone sidecar holding its own ChatGPT login
+   *                         is NOT a conduit: everything it reports is its own,
+   *                         and it is the only hop there is.
+   *
+   * Still imprecise in one direction, deliberately: a fleet running BOTH a
+   * self-hosting local Anthropic backend and Codex accounts reads the former as
+   * a conduit. Narrowing that would mean correlating the two hops of one turn,
+   * which nothing here can do — they are separate requests sharing no id — and
+   * the cost of the false positive is a row that under-reports rather than one
+   * that misroutes.
+   *
+   * @param {any} account
+   */
+  _isCodexConduit(account) {
+    return isLocalUpstream(account)
+      && providerOf(account) === DEFAULT_PROVIDER
+      && this.accounts.some(a => providerOf(a) === 'codex');
+  }
+
   /**
    * Update cumulative token usage from response body data.
    */
   updateUsage(accountIndex, inputTokens, outputTokens) {
     const account = this.accounts[accountIndex];
-    if (!account) return;
+    if (!account || this._isCodexConduit(account)) return;
     if (inputTokens) account.usage.totalInputTokens += inputTokens;
     if (outputTokens) account.usage.totalOutputTokens += outputTokens;
   }
@@ -3588,6 +3627,22 @@ export class AccountManager {
    */
   recordTokenUsage(accountIndex, sessionId, model, usage) {
     if (!usage) return;
+    // A conduit hop is the SAME tokens, translated: the sidecar rebuilt this
+    // report out of the Responses usage the pool sent it, and the pool's own hop
+    // records the original a moment later. Both scopes would double — the two
+    // account rows are distinct, but a session is one row and carries the same
+    // id on both hops, so its context and spend would read twice the truth.
+    //
+    // Dropped rather than deduplicated because there is nothing to deduplicate
+    // against: the two hops are separate requests that share no id, and the
+    // conduit spends nothing of its own anyway (its login is a stub). Booking at
+    // the hop that really spent is what keeps one turn one record.
+    //
+    // Only the ACCOUNT-scoped and SESSION-scoped counters stop here. Per-client
+    // attribution still runs on the inbound hop, in the caller, because that is
+    // the only hop that can see who asked: the outbound one comes from the
+    // sidecar on loopback and carries no client identity at all.
+    if (this._isCodexConduit(this.accounts[accountIndex])) return;
     // The same resolver routing uses, so a token total and a routing decision
     // agree about which family a request belonged to. Resolved here rather than
     // at the call sites: they parse a wire format and have no business knowing

package/src/claude-env.js

@@ -76,6 +76,66 @@ export function mergeNoProxy(...inherited) {
   return out.join(',');
 }
 
+/** The two ways a launched client can reach the proxy. */
+export const CLIENT_MODES = ['mitm', 'base-url'];
+
+/**
+ * Which mode `run` and `env` use: a `--mitm` or `--no-mitm` flag decides, else
+ * the config's `defaultClientMode`, else MITM.
+ *
+ * MITM routes every request of the launched client through the proxy, so the
+ * hard-coded api.anthropic.com endpoints and the Codex CLI (which honours only
+ * proxy variables) are covered. It is also the whole point of the setting: with
+ * `eval "$(teamclaude env)"` the proxy variables are shell-wide, and every other
+ * tool in that shell — gh, git, a package manager — follows them to a listener
+ * that only speaks to two hosts (#382). An operator who lives in such a shell
+ * sets `defaultClientMode: "base-url"` once and opts back in per launch.
+ *
+ * @param {{ defaultClientMode?: string }|null|undefined} config
+ * @param {string[]} flags  the invocation's own arguments
+ * @returns {'mitm'|'base-url'}
+ */
+export function resolveClientMode(config, flags) {
+  const mitm = flags.includes('--mitm');
+  const noMitm = flags.includes('--no-mitm');
+  if (mitm && noMitm) throw new Error('choose either --mitm or --no-mitm');
+  if (mitm) return 'mitm';
+  if (noMitm) return 'base-url';
+  return config?.defaultClientMode === 'base-url' ? 'base-url' : 'mitm';
+}
+
+const SHELL_PROXY_VARS = ['HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'http_proxy', 'https_proxy', 'all_proxy'];
+
+/**
+ * @param {unknown} value
+ * @param {number} port
+ */
+function pointsAtLoopback(value, port) {
+  if (!value) return false;
+  try {
+    const url = new URL(String(value));
+    const host = url.hostname.replace(/^\[|\]$/g, '').toLowerCase();
+    return ['127.0.0.1', 'localhost', '::1'].includes(host) && Number(url.port || 80) === port;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * `unset` lines for proxy variables a previous MITM-mode eval left in the
+ * shell, so re-evaluating in base-URL mode takes the proxy back out of it. Only
+ * a value naming THIS proxy's loopback port is touched: a real corporate proxy
+ * in the same variables is the operator's and stays.
+ *
+ * @param {unknown} port
+ * @param {NodeJS.ProcessEnv} [env]
+ * @returns {string[]}
+ */
+export function clearSelfProxyEnvLines(port, env = process.env) {
+  const checkedPort = validPort(port);
+  return SHELL_PROXY_VARS.filter(name => pointsAtLoopback(env[name], checkedPort)).map(name => `unset ${name}`);
+}
+
 // Build the shell `export` lines that point Claude Code — or any tool that
 // spawns it, e.g. an agent multiplexer — at the proxy. This is the same
 // environment `teamclaude run` sets up, but emitted for `eval "$(teamclaude

package/src/config.js

@@ -101,6 +101,7 @@ export function createDefaultConfig() {
     sessionTitles: { enabled: false, width: 18 },
     projection: { enabled: true, windowMinutes: 90, wasteFloor: 0.1 },
     eventLogging: 'hide',
+    defaultClientMode: 'mitm',
     activityLog: null,
     autoRestart: false,
     blockedModels: [],

package/src/index.js

@@ -31,7 +31,7 @@ import { ensureCerts, mitmHosts } from './mitm.js';
 import { Prober } from './prober.js';
 import { Warmer } from './warmer.js';
 import { createRollingWarmupSchedule, formatWarmupScheduleConfirmation, resolveWarmupConfig, resolveWarmupSchedule } from './warmup-schedule.js';
-import { Sidecar } from './sidecar.js';
+import { Sidecar, SIDECAR_DRAIN_GRACE_MS, SIDECAR_SHUTDOWN_GRACE_MS } from './sidecar.js';
 import { TUI } from './tui.js';
 import { SessionTitles } from './session-titles.js';
 import { RemoteControl, createAttachSession } from './tui-remote.js';
@@ -42,7 +42,7 @@ import { createVersionSource, UpdateWatcher } from './update-watch.js';
 import { renderStatus, formatPercent } from './status-renderer.js';
 import { sanitizeText } from './safe-text.js';
 import { ClientUsageTracker, UsageDimensionTracker } from './client-usage.js';
-import { buildClaudeEnvLines, buildCustomModelAgents, buildCustomModelSettings, buildCustomModelVars, bypassesAllHosts, encodePinComponent, mergeNoProxy } from './claude-env.js';
+import { buildClaudeEnvLines, buildCustomModelAgents, buildCustomModelSettings, buildCustomModelVars, bypassesAllHosts, clearSelfProxyEnvLines, encodePinComponent, mergeNoProxy, resolveClientMode } from './claude-env.js';
 import { serviceKind, installService, uninstallService, serviceStatus, renderService, logPath } from './service.js';
 import { formatTerminalTitle, titleSequence, TITLE_STACK_PUSH, TITLE_STACK_POP } from './terminal-title.js';
 import { getUpstreamProxy, describeProxy, describeSelfProxy } from './upstream-proxy.js';
@@ -474,6 +474,8 @@ async function serverCommand() {
     // Both are read per request off this object (server.js) and the TUI already
     // persists them; without this a hand edit or another writer waited for a restart.
     config.eventLogging = diskConfig.eventLogging || 'hide';
+    // Read by `run`/`env` from disk, but the TUI settings screen shows it live.
+    config.defaultClientMode = diskConfig.defaultClientMode === 'base-url' ? 'base-url' : 'mitm';
     config.blockedModels = Array.isArray(diskConfig.blockedModels) ? diskConfig.blockedModels : [];
     config.projection = diskConfig.projection;
     accountManager.setProjection(config.projection);
@@ -537,6 +539,7 @@ async function serverCommand() {
         // screen too; the server reads them live from `config`, but without this
         // the edit never reached disk and was silently undone by the next start.
         if (config.eventLogging != null) diskConfig.eventLogging = config.eventLogging;
+        if (config.defaultClientMode != null) diskConfig.defaultClientMode = config.defaultClientMode;
         if (config.blockedModels != null) diskConfig.blockedModels = config.blockedModels;
         if (config.sessionTitles != null) diskConfig.sessionTitles = config.sessionTitles;
         // Persist the route table (edited from the TUI routes screen).
@@ -800,7 +803,20 @@ async function serverCommand() {
     prober?.stop();
     warmer?.stop();
     eventLoopMonitor.stop();
-    sidecar?.stop();
+    // Started here, awaited at the end, so the sidecar's grace runs BESIDE the
+    // rest of this teardown instead of after it.
+    //
+    // Forcing, because this path already made that choice for everything else:
+    // it destroys live streaming connections a few lines down and hard-exits on
+    // a timer. The sidecar's first SIGTERM only BEGINS its shutdown, which an
+    // in-flight request holds open, so asking politely and leaving is how a
+    // copy of it outlived the server and kept its port — the exact orphan
+    // Sidecar._reapOrphan then had to clean up on the next start.
+    //
+    // Never rejects by construction; caught anyway, because an unhandled one
+    // between here and the await below would be this process's last word.
+    const sidecarStopped = Promise.resolve(
+      sidecar?.stop({ graceMs: SIDECAR_SHUTDOWN_GRACE_MS, force: true })).catch(() => {});
     if (quotaSaveInterval) clearInterval(quotaSaveInterval);
     await persistQuotaState();
     // Don't linger waiting on keep-alive / streaming connections: actively
@@ -808,7 +824,12 @@ async function serverCommand() {
     // short grace period in case anything still hangs.
     setTimeout(() => process.exit(0), 2000).unref?.();
     server.closeAllConnections?.();
-    server.close(() => process.exit(0));
+    const closed = new Promise(resolve => server.close(() => resolve(undefined)));
+    // Both, not the first of the two. Exiting the moment the listener closed is
+    // what walked out on the sidecar mid-kill; the timer above is still what
+    // guarantees this ends.
+    await Promise.all([closed, sidecarStopped]);
+    process.exit(0);
   }
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
@@ -865,7 +886,13 @@ async function serverCommand() {
       console.log(drained
         ? `[TeamClaude] Drained in ${(waitedMs / 1000).toFixed(1)}s. Restarting on the new build.`
         : `[TeamClaude] ${inFlight} request(s) still in flight after ${(waitedMs / 1000).toFixed(0)}s — restarting anyway.`);
-      sidecar?.stop();
+      // Patient, and awaited: the drain above already proved nothing is in
+      // flight, so one SIGTERM is all this takes and the wait is only there to
+      // bound it. Awaited because the relaunch wants the port a moment later
+      // and this is the only place that can hand it over cleanly. No forcing
+      // signal — the whole point of this path is to cost the fleet nothing, and
+      // a sidecar that somehow outlasts the grace is what _reapOrphan is for.
+      await sidecar?.stop({ graceMs: SIDECAR_DRAIN_GRACE_MS });
       if (quotaSaveInterval) clearInterval(quotaSaveInterval);
       await persistQuotaState();
     } catch (err) {
@@ -1147,7 +1174,13 @@ async function envCommand() {
     process.exit(1);
   }
   const port = config.proxy.port;
-  const useMitm = !args.slice(1).includes('--no-mitm');
+  let useMitm;
+  try {
+    useMitm = resolveClientMode(config, args.slice(1)) === 'mitm';
+  } catch (/** @type {any} */ err) {
+    process.stderr.write(`teamclaude env: ${err.message}\n`);
+    process.exit(1);
+  }
 
   let caPath = null;
   // The leaf has to name every host MITM will intercept, or the CONNECT for
@@ -1166,6 +1199,9 @@ async function envCommand() {
       inheritedNoProxy: [process.env.NO_PROXY, process.env.no_proxy].filter(Boolean).join(','),
       customModels: config.customModels,
     });
+    // Base-URL mode takes the proxy back OUT of a shell an earlier MITM eval
+    // put it into; only this proxy's own loopback address is unset.
+    if (!useMitm) lines.push(...clearSelfProxyEnvLines(port));
   } catch (err) {
     // A bad proxy.port. Nothing reaches stdout: the shell is eval'ing it.
     process.stderr.write(`teamclaude env: ${err.message} (in ${getConfigPath()})\n`);
@@ -1183,7 +1219,9 @@ async function envCommand() {
       process.stderr.write(`# warning: no account named "${account}" in the config — the proxy will refuse this pin\n`);
     }
   }
-  process.stderr.write(`# apply to this shell:  eval "$(teamclaude env${useMitm ? '' : ' --no-mitm'})"\n`);
+  // The flag that reproduces this mode whatever the config's default says.
+  process.stderr.write(`# apply to this shell:  eval "$(teamclaude env${useMitm ? ' --mitm' : ' --no-mitm'})"\n`);
+  process.stderr.write(`# default mode is ${config.defaultClientMode === 'base-url' ? 'base-URL' : 'MITM'} (config defaultClientMode; the TUI settings screen toggles it)\n`);
   if (!(await isProxyUp(port))) {
     process.stderr.write(`# note: proxy not running on port ${port} — start it with: teamclaude server\n`);
   }
@@ -1200,12 +1238,18 @@ async function runCommand() {
   // Args after 'run'. teamclaude flags (e.g. --no-mitm) are recognized only
   // before an optional `--` separator; everything after `--` goes verbatim to
   // claude. MITM forward-proxy mode is the default so hardcoded api.anthropic.com
-  // endpoints are intercepted too; --no-mitm opts back into base-URL-only routing.
-  // --mitm is still accepted (now a no-op) for backward compatibility.
+  // endpoints are intercepted too; the config's `defaultClientMode` can make
+  // base-URL the default instead, and --mitm / --no-mitm decide per launch.
   const rest = args.slice(1);
   const sep = rest.indexOf('--');
   const tcFlags = sep >= 0 ? rest.slice(0, sep) : rest;
-  const useMitm = !tcFlags.includes('--no-mitm');
+  let useMitm;
+  try {
+    useMitm = resolveClientMode(config, tcFlags) === 'mitm';
+  } catch (/** @type {any} */ err) {
+    console.error(`[TeamClaude] ${err.message}`);
+    process.exit(1);
+  }
   const autoFallback = tcFlags.includes('--auto-fallback');
   const claudeArgs = sep >= 0
     ? rest.slice(sep + 1)
@@ -2283,10 +2327,12 @@ Commands:
   login               OAuth login via browser
   login --token       OAuth login via copy/paste (no local callback; for headless/remote)
   login --api         Add an API key account
-  env [--no-mitm]     Print export lines to point Claude Code at the proxy, for
-                      'eval "$(teamclaude env)"' (MITM forward-proxy by default;
-                      --no-mitm for base-URL only). Handy for agent multiplexers
-                      that spawn claude themselves instead of via 'teamclaude run'
+  env [--mitm|--no-mitm]
+                      Print export lines to point Claude Code at the proxy, for
+                      'eval "$(teamclaude env)"'. MITM forward-proxy unless the
+                      config's defaultClientMode is "base-url"; a flag decides
+                      per call. Handy for agent multiplexers that spawn claude
+                      themselves instead of via 'teamclaude run'
   run [--no-mitm] [--auto-fallback] [-- args...]
                       Run Claude Code through the proxy (errors if it's down,
                       unless --auto-fallback launches claude directly instead).

package/src/responses-usage.js

@@ -0,0 +1,131 @@
+// Token usage as OpenAI's Responses API reports it, rewritten into the shape
+// the rest of this proxy books.
+//
+// Every counter here — the account totals, the per-session ones, the per-client
+// ones — speaks Anthropic's usage vocabulary, because that is the only shape
+// this proxy had to read for its first year. Codex traffic is a passthrough, so
+// it arrives in OpenAI's vocabulary instead, and the two disagree in a way that
+// is easy to miss because they share field NAMES:
+//
+//   Anthropic   `input_tokens` is the UNCACHED input. The cached part is
+//               reported separately (`cache_read_input_tokens`,
+//               `cache_creation_input_tokens`) and the three are disjoint — the
+//               readers here add them up to get a context size or a total.
+//
+//   Responses   `input_tokens` is the WHOLE prompt, with the cached part named
+//               again underneath it as `input_tokens_details.cached_tokens`.
+//               Booking it as Anthropic's would count the cached prefix twice
+//               once the cache field is also read, and on Codex traffic that
+//               prefix is most of the prompt.
+//
+// So the subtraction below is the entire point of this file: the cached tokens
+// move out of `input_tokens` and into `cache_read_input_tokens`, leaving three
+// disjoint figures that every existing reader already knows how to add.
+//
+// `output_tokens_details.reasoning_tokens` is NOT added to the output side —
+// it is a breakdown of `output_tokens`, not a second quantity beside it (a real
+// turn: input 54904, output 132 of which 18 reasoning, total_tokens 55036 =
+// 54904 + 132). `input_tokens_details.cache_write_tokens` is likewise left
+// folded into the uncached remainder rather than mapped onto Anthropic's
+// `cache_creation_input_tokens`: a cache write IS fresh input being processed,
+// OpenAI does not bill it at a premium the way Anthropic does, and inventing a
+// fourth disjoint bucket out of a field whose subset relationship is not stated
+// anywhere would risk a total that no longer adds up.
+//
+// Shape confirmed against OpenAI's generated SDK types (`ResponseUsage`), the
+// Codex CLI's own per-turn records, and the sidecar binary that translates this
+// same body for the hop before us.
+
+/** Terminal stream events, the only ones that carry a settled usage object.
+ *
+ *  Named rather than inferred from "the event has a usage object": EVERY
+ *  `response.*` event carries the whole response envelope, so `response.created`
+ *  and `response.in_progress` have a `usage` key too — null today. Reading the
+ *  key would make this proxy's accounting depend on that staying null, and an
+ *  upstream that started reporting progress figures would be counted twice. A
+ *  fixed set of terminal names makes a second report unrepresentable instead.
+ *
+ *  `response.failed` is in the set because a failure that got far enough to
+ *  report figures still spent them; when it carries none — the usual case — the
+ *  normaliser below returns null and nothing is recorded.
+ */
+const TERMINAL_EVENTS = new Set(['response.completed', 'response.incomplete', 'response.failed']);
+
+/**
+ * A wire figure as a non-negative integer. Everything here is untrusted JSON:
+ * a string, a null, a NaN or a negative count must read as "nothing reported"
+ * rather than poison a cumulative total that is never recomputed.
+ *
+ * @param {unknown} v
+ * @returns {number}
+ */
+function count(v) {
+  return typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.trunc(v) : 0;
+}
+
+/**
+ * A Responses `usage` object in Anthropic's disjoint shape, or null when there
+ * is nothing to record.
+ *
+ * Null for an absent, non-object or all-zero usage, because the recorders
+ * downstream treat a written record as an observation that happened: an
+ * all-zero one would claim a report arrived and count against `reports`, which
+ * is the one thing that distinguishes "upstream told us nothing" from "upstream
+ * told us zero".
+ *
+ * @param {any} usage
+ * @returns {{input_tokens: number, output_tokens: number, cache_read_input_tokens: number}|null}
+ */
+export function normalizeResponsesUsage(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+  const prompt = count(usage.input_tokens);
+  const output = count(usage.output_tokens);
+  // Clamped to the prompt it is a part of. Upstream cannot report more cached
+  // tokens than input tokens, but the uncached remainder is a subtraction, and
+  // an unclamped one would go negative and silently shrink a lifetime total.
+  const cached = Math.min(count(usage.input_tokens_details?.cached_tokens), prompt);
+  if (!prompt && !output) return null;
+  return {
+    input_tokens: prompt - cached,
+    output_tokens: output,
+    cache_read_input_tokens: cached,
+  };
+}
+
+/**
+ * Usage from one parsed SSE event of a Responses stream, or null when this
+ * event is not a terminal one (the common case — a stream is mostly deltas).
+ *
+ * @param {any} event
+ */
+export function responsesEventUsage(event) {
+  if (!event || !TERMINAL_EVENTS.has(event.type)) return null;
+  return normalizeResponsesUsage(event.response?.usage);
+}
+
+/**
+ * Usage from a NON-streaming Responses body, or null when the body is not one.
+ *
+ * Two independent tells, either of which is enough, and neither of which an
+ * Anthropic message body can produce:
+ *
+ *   `object: "response"`     what the Responses envelope calls itself.
+ *   `input_tokens_details`   present exactly when a prompt-cache breakdown is
+ *                            reported, which is the case that actually needs
+ *                            rewriting.
+ *
+ * Both, rather than either alone, because the first is the honest discriminator
+ * while the second is the one that matters: a Responses body that reports no
+ * cache breakdown at all needs no rewriting — its `input_tokens` is already
+ * uncached input — so a body that somehow shows neither tell is read as
+ * Anthropic's and lands on exactly the same numbers it would have anyway.
+ *
+ * @param {any} json
+ */
+export function responsesBodyUsage(json) {
+  if (!json || typeof json !== 'object') return null;
+  const usage = json.usage;
+  const tagged = json.object === 'response'
+    || (usage != null && typeof usage === 'object' && usage.input_tokens_details != null);
+  return tagged ? normalizeResponsesUsage(usage) : null;
+}

package/src/server.js

@@ -19,6 +19,7 @@ import { safeLine } from './safe-text.js';
 import { forwardRefusal, guardedLookup, FORBIDDEN_FORWARD } from './forward-target.js';
 import { renderDashboardHtml, dashboardCsp } from './dashboard.js';
 import { createUsageRecorder, resolveUsageDimensions, usageDimensionHeaderNames } from './client-usage.js';
+import { responsesEventUsage, responsesBodyUsage } from './responses-usage.js';
 import { classificationPath } from './classification-path.js';
 /** @typedef {import('./types.js').CodedError} CodedError */
 
@@ -3041,8 +3042,24 @@ export function createSseLineScanner(onLine, maxChars = SSE_MAX_LINE_CHARS) {
 // over. One record per message is what makes double counting unrepresentable
 // rather than merely avoided.
 //
-// Reads one `data:` line. Anthropic's events carry exactly one, so a line is an
-// event for this purpose, and the scanner above never has to hold more.
+// A Responses stream (the Codex path) instead reports once, at the end, and in
+// OpenAI's own vocabulary — so it is rewritten into Anthropic's disjoint shape
+// before it reaches either counter (src/responses-usage.js explains why the two
+// disagree). It rides this function rather than a parser of its own because the
+// line is ALREADY parsed here: the branch costs a Set lookup on a string, not a
+// second pass over the stream. Nothing else would be cheap — a Responses stream
+// is mostly text deltas, and the settled figures arrive on one event near the end
+// with no header or marker to find it by.
+//
+// Reads one `data:` line. Both dialects carry exactly one per event, so a line
+// is an event for this purpose, and the scanner above never has to hold more.
+/**
+ * @param {string} line
+ * @param {number} accountIndex
+ * @param {any} accountManager
+ * @param {((inputTokens: number, outputTokens: number) => void)|null} [onUsage]
+ * @param {Record<string, any>|null} [merged]
+ */
 function parseSSEDataLine(line, accountIndex, accountManager, onUsage = null, merged = null) {
   if (!line.startsWith('data: ')) return;
 
@@ -3056,6 +3073,15 @@ function parseSSEDataLine(line, accountIndex, accountManager, onUsage = null, me
       accountManager.updateUsage(accountIndex, 0, data.usage.output_tokens);
       onUsage?.(0, data.usage.output_tokens || 0);
       if (merged) Object.assign(merged, data.usage);
+    } else {
+      // Both sides settle at once here, so unlike the Anthropic branches above
+      // this is a single incremental update rather than one per side.
+      const usage = responsesEventUsage(data);
+      if (usage) {
+        accountManager.updateUsage(accountIndex, usage.input_tokens, usage.output_tokens);
+        onUsage?.(usage.input_tokens, usage.output_tokens);
+        if (merged) Object.assign(merged, usage);
+      }
     }
   } catch {
     // not valid JSON, skip
@@ -3066,9 +3092,16 @@ function extractUsageFromBody(buffer, accountIndex, accountManager, onUsage = nu
   try {
     const json = JSON.parse(buffer.toString());
     if (json.usage) {
-      accountManager.updateUsage(accountIndex, json.usage.input_tokens, json.usage.output_tokens);
-      onUsage?.(json.usage.input_tokens || 0, json.usage.output_tokens || 0);
-      accountManager.recordTokenUsage(accountIndex, sessionId, model, json.usage);
+      // A buffered Responses body reports under the same two field NAMES with a
+      // different meaning, so reading it as Anthropic's would book the cached
+      // prefix as fresh input and never book it as a cache read at all. Only a
+      // body that says it is one is rewritten; anything else — including a
+      // Responses body carrying no figures to rewrite — falls through to the
+      // reading this had before, unchanged.
+      const usage = responsesBodyUsage(json) || json.usage;
+      accountManager.updateUsage(accountIndex, usage.input_tokens, usage.output_tokens);
+      onUsage?.(usage.input_tokens || 0, usage.output_tokens || 0);
+      accountManager.recordTokenUsage(accountIndex, sessionId, model, usage);
     }
   } catch {
     // not JSON or no usage

package/src/sidecar.js

@@ -10,7 +10,9 @@
 //
 // stdout is ignored (sidecars keep their own log files); stderr's last few
 // lines are kept in a ring buffer so `getStatus()` can say WHY a sidecar is
-// crash-looping without anyone hunting for its logs.
+// crash-looping without anyone hunting for its logs. What the sidecar has to
+// say about its own health rides along beside that, polled off its endpoint
+// rather than inferred from ours — see the readout section below.
 //
 // One failure mode earned its own handling. A sidecar binds a fixed port, so a
 // copy that outlives its server keeps that port and every later server fails to
@@ -20,6 +22,35 @@
 
 import { spawn, spawnSync } from 'node:child_process';
 
+// How long each caller of stop() waits for a child to go, and why the two
+// differ. The sidecar (claude-code-proxy v0.1.40 and later) reads the FIRST
+// SIGTERM as "begin a graceful shutdown", which an in-flight request holds
+// open, and only forces exit on a second signal. Measured against that build:
+// idle it exits in ~30ms, even with an idle keep-alive socket still attached;
+// with one request in flight it was still serving 3s after the first signal and
+// died 4ms after the second.
+//
+// So the wait is not about the sidecar being slow — it is about whether the
+// caller has already decided to interrupt work in flight.
+//
+//   SHUTDOWN — ctrl-c. The caller destroys live client connections and
+//   hard-exits 2s later, so the sidecar's remaining work has nowhere to go
+//   anyway. Long enough for the idle exit by a wide margin, short enough that
+//   the escalation below still completes inside that 2s budget.
+//
+//   DRAIN — the restart path, which waits for the fleet to go idle first. There
+//   is nothing left in flight to interrupt and nothing is watching, so the
+//   number only has to be larger than an unhurried exit; it exists to bound the
+//   wait, not to ration it. No escalation goes with it (see stop()).
+export const SIDECAR_SHUTDOWN_GRACE_MS = 500;
+export const SIDECAR_DRAIN_GRACE_MS = 5_000;
+
+// Allowed to the forcing signal, and again to SIGKILL. Both end the process
+// where it stands — upstream's second signal is a bare process::exit(130) — so
+// this is a scheduling allowance for the exit to be observed, not a shutdown
+// budget of its own.
+const FORCE_STEP_MS = 250;
+
 /** Delay before restart attempt N (0-based): base, doubled per consecutive
  *  crash, capped. Pure so the schedule is testable without timers. */
 export function restartDelayMs(restarts, { baseRestartMs, maxRestartMs }) {
@@ -33,6 +64,71 @@ export function isBindConflict(line) {
   return /address already in use|address in use|EADDRINUSE/i.test(String(line));
 }
 
+// The sidecar's health readout, polled off its own /monitor endpoint.
+//
+// `--no-monitor` picks the sidecar's plain serve mode, which still builds a
+// monitor handle and still registers /monitor on the same router, so this needs
+// nothing changed about how the process is spawned — verified against
+// claude-code-proxy 0.1.40 with today's `sidecars[].command`.
+//
+// It is a READOUT, not a dependency. The endpoint belongs to upstream and its
+// shape can move under any rebase, so every field here is optional and every
+// failure — no listener, a timeout, a 404, a schema that no longer matches —
+// means "no numbers this time" and leaves the process line exactly as it was
+// before this existed. Nothing in here may throw at the supervisor or the TUI.
+
+/** How often to re-read it. The screen it feeds redraws every 500ms at its
+ *  busiest and every 5s when idle, so polling faster buys nothing an operator
+ *  could see; the sidecar's own dashboard uses 250ms because it draws per-
+ *  request progress, which this line does not. */
+const MONITOR_POLL_MS = 2_000;
+/** A local process answering from memory. Anything slower than this is a
+ *  sidecar with worse problems than a missing status line. */
+const MONITOR_TIMEOUT_MS = 500;
+/** Ceiling on the reply. The body carries the whole recent ring (200 requests,
+ *  each with an upstream error string of no fixed length), and when the sidecar
+ *  is blocked the thing answering on its port is by definition NOT the sidecar. */
+const MONITOR_MAX_BYTES = 1024 * 1024;
+
+/** The port this sidecar was told to listen on, or null when the command does
+ *  not say. Read from the entry's own args rather than assuming 18765: the port
+ *  is the operator's choice, and a readout aimed at the wrong one would report
+ *  a stranger's numbers.
+ *  @param {string[]|undefined} command
+ *  @returns {number|null}
+ */
+export function monitorPort(command) {
+  const args = Array.isArray(command) ? command : [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = String(args[i]);
+    const value = arg === '--port' ? args[i + 1] : arg.startsWith('--port=') ? arg.slice(7) : null;
+    if (value == null) continue;
+    const port = Number(value);
+    if (Number.isInteger(port) && port > 0 && port < 65_536) return port;
+  }
+  return null;
+}
+
+/** The two numbers the ⚙ line wants, out of whatever /monitor answered.
+ *
+ *  `active` is the requests the sidecar has in flight right now. Errors are
+ *  counted over `recent`, its ring of finished requests, which makes the number
+ *  "failing lately" rather than "failed ever" — the question an operator
+ *  glancing at a status line is actually asking, and the only one a bounded
+ *  ring can answer honestly. null means the payload did not say.
+ *  @param {any} payload
+ *  @returns {{activeRequests: number|null, recentErrors: number|null}|null}
+ */
+export function monitorCounts(payload) {
+  const snapshot = payload?.snapshot;
+  const active = Array.isArray(snapshot?.active) ? snapshot.active.length : null;
+  const recent = Array.isArray(snapshot?.recent)
+    ? snapshot.recent.filter((/** @type {any} */ r) => r?.status === 'failed').length
+    : null;
+  if (active == null && recent == null) return null;   // not a shape we know
+  return { activeRequests: active, recentErrors: recent };
+}
+
 export class Sidecar {
   constructor(entries, {
     spawnFn = defaultSpawn,
@@ -45,6 +141,8 @@ export class Sidecar {
     onPids = null,
     readProcess = defaultReadProcess,
     killFn = (pid, signal) => process.kill(pid, signal),
+    fetchFn = fetch,
+    monitorPollMs = MONITOR_POLL_MS,
   } = {}) {
     this.entries = Array.isArray(entries) ? entries : [];
     this.spawnFn = spawnFn;
@@ -59,6 +157,8 @@ export class Sidecar {
     this.onPids = onPids;
     this.readProcess = readProcess;
     this.killFn = killFn;
+    this.fetchFn = fetchFn;
+    this.monitorPollMs = monitorPollMs;
     this.stopping = false;
     // Per-entry runtime state, keyed by entry (parallel array to this.entries).
     this.states = this.entries.map(entry => ({
@@ -70,6 +170,12 @@ export class Sidecar {
       timer: null,
       stderrTail: [],
       blocked: null,   // stderr line proving the port is held, else null
+      // The health readout: where to ask, when to ask again, and the last
+      // answer (null until one arrives, and again whenever one stops arriving).
+      monitorPort: monitorPort(entry.command),
+      monitorTimer: null,
+      /** @type {{activeRequests: number|null, recentErrors: number|null}|null} */
+      monitor: null,
     }));
   }
 
@@ -80,12 +186,53 @@ export class Sidecar {
     }
   }
 
-  stop() {
+  /** Stop every supervised child, and resolve once they are gone or the grace
+   *  runs out — whichever happens first.
+   *
+   *  A caller that does not await this gets what stop() always did: the signal
+   *  is sent synchronously and the promise is nobody's business. A caller that
+   *  DOES await it is saying the thing it is about to do next — exit — must not
+   *  happen while a child is still holding its port.
+   *
+   *  `force` is for a caller that has already chosen to be abrupt with
+   *  everything else. It escalates when the grace expires: a second SIGTERM,
+   *  which is the forcing signal for this sidecar, then SIGKILL, so this keeps
+   *  working if that ever changes again. Anything that wants the sidecar to
+   *  finish its work leaves it off and simply waits.
+   *
+   *  @param {{graceMs?: number, force?: boolean}} [opts]
+   *  @returns {Promise<void>}
+   */
+  async stop({ graceMs = 0, force = false } = {}) {
+    // Both of these before a single signal goes out: a child killed while its
+    // respawn timer is pending would be replaced by the very timer it was
+    // killed to cancel.
     this.stopping = true;
+    const gone = [];
     for (const state of this.states) {
       if (state.timer) { clearTimeout(state.timer); state.timer = null; }
-      state.child?.kill('SIGTERM');
+      this._stopMonitor(state);
+      if (state.child) gone.push(this._stopChild(state.child, graceMs, force));
     }
+    await Promise.all(gone);
+  }
+
+  /** Signal one child and wait it out, escalating when asked.
+   *  @param {any} child
+   *  @param {number} graceMs
+   *  @param {boolean} force
+   */
+  async _stopChild(child, graceMs, force) {
+    // Subscribed BEFORE the signal, or a child that dies instantly resolves
+    // nothing and every wait below runs to its full length.
+    const gone = childGone(child);
+    signalChild(child, 'SIGTERM');
+    if (await settledWithin(gone, graceMs)) return;
+    if (!force) return;
+    signalChild(child, 'SIGTERM');
+    if (await settledWithin(gone, FORCE_STEP_MS)) return;
+    signalChild(child, 'SIGKILL');
+    await settledWithin(gone, FORCE_STEP_MS);
   }
 
   getStatus() {
@@ -100,6 +247,10 @@ export class Sidecar {
       blocked: !!state.blocked,
       blockedReason: state.blocked,
       stderrTail: [...state.stderrTail],
+      // Straight off the sidecar's /monitor, and null whenever it did not
+      // answer — which a consumer must be able to tell apart from a zero.
+      activeRequests: state.monitor?.activeRequests ?? null,
+      recentErrors: state.monitor?.recentErrors ?? null,
     }));
   }
 
@@ -124,6 +275,12 @@ export class Sidecar {
    *  last test, and a sidecar belonging to another live server fails the second,
    *  so neither is touched. The port may take a moment to free after this; the
    *  ordinary restart backoff covers that.
+   *
+   *  One SIGTERM is still the right signal, and now for two reasons rather than
+   *  one. An orphan of a SIGKILLed server was never signalled, so this is its
+   *  first: idle, it goes at once. An orphan that outran stop()'s escalation
+   *  already has one, so this is its SECOND — the forcing signal — which is
+   *  precisely what a leftover still clinging to the port has earned.
    */
   _reapOrphan(state) {
     const pid = Number(this.savedPids[state.entry.name]?.pid);
@@ -172,6 +329,7 @@ export class Sidecar {
       if (state.child !== child) return;
       this._onDown(state, signal ? `signal ${signal}` : `code ${code}`);
     });
+    this._scheduleMonitor(state);
   }
 
   _onDown(state, lastExit) {
@@ -180,6 +338,9 @@ export class Sidecar {
     if (state.startedAt && Date.now() - state.startedAt >= this.stableMs) state.restarts = 0;
     state.child = null;
     state.lastExit = lastExit;
+    // Nothing to poll and nothing true left to say: "2 active" printed beside
+    // "down (code 1)" describes a process that no longer exists.
+    this._stopMonitor(state);
     if (this.stopping) return;
     const delay = restartDelayMs(state.restarts, this);
     // Retrying still makes sense while blocked — a port held by a process we
@@ -196,6 +357,65 @@ export class Sidecar {
     state.timer.unref?.();
   }
 
+  /** Arm the next health poll for this entry, if there is anything to poll.
+   *  @param {any} state */
+  _scheduleMonitor(state) {
+    if (this.stopping || !state.child || !state.monitorPort || state.monitorTimer) return;
+    const child = state.child;
+    state.monitorTimer = setTimeout(() => {
+      state.monitorTimer = null;
+      this._readMonitor(state.monitorPort).then(counts => {
+        // Everything below is conditional on the poll still being about the
+        // same running child. It was in flight for up to a timeout, and in that
+        // window the sidecar can have died, been respawned, or been stopped —
+        // after which these numbers describe a process that is not there, and
+        // a second loop would be left polling beside the first.
+        if (this.stopping || state.child !== child) return;
+        state.monitor = counts;
+        this._scheduleMonitor(state);
+      });
+    }, this.monitorPollMs);
+    // A status line may not be the reason this process is still alive.
+    state.monitorTimer.unref?.();
+  }
+
+  /** @param {any} state */
+  _stopMonitor(state) {
+    if (state.monitorTimer) { clearTimeout(state.monitorTimer); state.monitorTimer = null; }
+    state.monitor = null;
+  }
+
+  /** Ask the endpoint once. Never rejects and never throws: a readout that
+   *  failed is a readout with nothing in it.
+   *  @param {number} port
+   *  @returns {Promise<{activeRequests: number|null, recentErrors: number|null}|null>}
+   */
+  async _readMonitor(port) {
+    try {
+      // Loopback only. The sidecar's own handler refuses a non-local peer, and
+      // asking some other host about "our" process would mean nothing anyway.
+      const res = await this.fetchFn(`http://127.0.0.1:${port}/monitor`, {
+        signal: AbortSignal.timeout(MONITOR_TIMEOUT_MS),
+      });
+      if (!res?.ok) return null;
+      // A declared length is how this reply is bounded BEFORE a byte of it is
+      // buffered. The sidecar always sends one; whatever else may be holding
+      // that port — the case `blocked` exists for — is under no such
+      // obligation, and an unbounded body read on a timer is a memory leak with
+      // a schedule. Matched rather than coerced: Number(null) and Number('')
+      // are both 0, which would wave an undeclared body past as an empty one.
+      const declared = res.headers?.get?.('content-length');
+      const bytes = /^\d+$/.test(String(declared)) ? Number(declared) : NaN;
+      if (!(bytes <= MONITOR_MAX_BYTES)) return null;
+      return monitorCounts(JSON.parse(await res.text()));
+    } catch {
+      // No listener, a timeout, a body that is not JSON, an endpoint upstream
+      // has moved: one answer covers them all, and none of them is this
+      // supervisor's to report.
+      return null;
+    }
+  }
+
   _publishPids() {
     if (!this.onPids) return;
     // Persistence is the owner's business and best-effort: failing to record a
@@ -213,6 +433,49 @@ export class Sidecar {
   }
 }
 
+/** A promise for "this child is no longer running".
+ *
+ *  'exit' is the event that answers the question stop() is really asking — the
+ *  port is free from that moment — but a child whose stdio outlives it emits
+ *  only 'close' afterwards, so both are taken and the first one wins.
+ *  @param {any} child
+ *  @returns {Promise<void>}
+ */
+function childGone(child) {
+  return new Promise(resolve => {
+    const done = () => resolve();
+    child.once?.('exit', done);
+    child.once?.('close', done);
+  });
+}
+
+/** True when `promise` settles within `ms`, false when the wait runs out.
+ *
+ *  The timer is deliberately NOT unref'd. Every caller here is on its way to a
+ *  specific exit code, and an unref'd wait would let an emptied event loop end
+ *  the process at 0 instead — silently turning a restart (75) into a stop. It
+ *  is bounded and cleared on the fast path, so it holds nothing open.
+ *  @param {Promise<void>} promise
+ *  @param {number} ms
+ *  @returns {Promise<boolean>}
+ */
+function settledWithin(promise, ms) {
+  if (!(ms > 0)) return Promise.resolve(false);
+  return new Promise(resolve => {
+    const timer = setTimeout(() => resolve(false), ms);
+    promise.then(() => { clearTimeout(timer); resolve(true); });
+  });
+}
+
+/** Signal a child, never throwing. A child that has already exited, or whose
+ *  handle no longer accepts the signal, IS the outcome being asked for.
+ *  @param {any} child
+ *  @param {NodeJS.Signals} signal
+ */
+function signalChild(child, signal) {
+  try { child.kill(signal); } catch { /* already gone, which is the point */ }
+}
+
 // Real spawner: stdout ignored (sidecars log to their own files), stderr piped
 // for the ring buffer.
 //

package/src/tui-remote.js

@@ -288,6 +288,11 @@ export class RemoteAccountManager {
       pid: Number.isFinite(sc?.pid) ? sc.pid : null,
       restarts: Number.isFinite(sc?.restarts) ? sc.restarts : 0,
       lastExit: sc?.lastExit == null ? null : text(sc.lastExit, 48),
+      // The health readout. A server too old to send these omits them, which is
+      // already what "the sidecar did not answer" looks like, so attach mode
+      // needs no version check — it simply draws the line it always drew.
+      activeRequests: Number.isFinite(sc?.activeRequests) ? sc.activeRequests : null,
+      recentErrors: Number.isFinite(sc?.recentErrors) ? sc.recentErrors : null,
     }));
     this.status = status;
     this.connected = true;

package/src/tui.js

@@ -857,6 +857,16 @@ export class TUI {
       enter: () => this._cycleEventLogging(+1),
     });
 
+    fields.push({
+      id: 'clientMode',
+      label: 'Client mode',
+      hint: '←→ toggle',
+      value: () => (this.config.defaultClientMode === 'base-url' ? yellow('base-url') : green('mitm')),
+      left: () => this._toggleClientMode(),
+      right: () => this._toggleClientMode(),
+      enter: () => this._toggleClientMode(),
+    });
+
     if (this.sessionTitles) {
       fields.push({
         id: 'sessionTitles',
@@ -1360,6 +1370,19 @@ export class TUI {
     if (this.running) this.render();
   }
 
+  async _toggleClientMode() {
+    // What `teamclaude run` and `env` do when no --mitm/--no-mitm flag is given.
+    // Base-URL keeps a shell's other tools off the proxy (#382); MITM covers the
+    // hard-coded endpoints and the Codex CLI. Read from disk by those commands,
+    // so the save is the whole application.
+    const next = this.config.defaultClientMode === 'base-url' ? 'mitm' : 'base-url';
+    this.config.defaultClientMode = next;
+    try { await this.saveConfig(this.config); }
+    catch (/** @type {any} */ e) { this._addLog(`Failed to save: ${e.message}`); }
+    this._addLog(`Default client mode: ${next} (run/env without a flag)`);
+    if (this.running) this.render();
+  }
+
   async _doClearSxKey() {
     this.config.sx = null;
     try { await this.saveConfig(this.config); }
@@ -1895,7 +1918,13 @@ export class TUI {
               : proc ? green('up') : green('ok');
       const pid = proc?.running ? dim(` pid ${proc.pid}`) : '';
       const restarts = proc?.restarts ? yellow(` ${proc.restarts} restarts`) : '';
-      return ` ${dim('⚙')} ${a.name} ${dim('→')} ${dim(host)}  ${state}${pid}${restarts}`;
+      // What the sidecar says about itself, when it says anything: it is polled
+      // off its own /monitor and the numbers are null whenever that did not
+      // answer. Shown only when non-zero — an idle sidecar has nothing to add,
+      // and "0 active 0 errors" on every line is how a readout becomes noise.
+      const active = proc?.activeRequests ? dim(` ${proc.activeRequests} active`) : '';
+      const errors = proc?.recentErrors ? yellow(` ${proc.recentErrors} errors`) : '';
+      return ` ${dim('⚙')} ${a.name} ${dim('→')} ${dim(host)}  ${state}${pid}${restarts}${active}${errors}`;
     });
   }
 
@@ -2106,6 +2135,10 @@ export class TUI {
     lines.push(row(byId('eventlog')));
     if (byId('sessionTitles')) lines.push(row(byId('sessionTitles')));
     lines.push('');
+    // ── Launch
+    lines.push(bold('  Launch') + dim('  — how `teamclaude run` and `env` reach the proxy when no flag says'));
+    lines.push(row(byId('clientMode')));
+    lines.push('');
     // ── Routing
     lines.push(bold('  Routing') + dim('  — pin model families to specific accounts, or block them outright'));
     lines.push(row(byId('routes')));