@dianshuv/copilot-api 0.12.0 → 0.13.1

package/dist/main.mjs

@@ -7,6 +7,7 @@ import path from "node:path";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
 import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { serve } from "srvx";
 import { PostHog } from "posthog-node";
 import pc from "picocolors";
@@ -474,6 +475,56 @@ async function getGitHubUser() {
 	return await response.json();
 }
 
+//#endregion
+//#region src/lib/tui/request-timings.ts
+/** Canonical phase keys — the Map keys double as TrackedRequest field names. */
+const TIMING = {
+	TOKENIZE: "tokenizeMs",
+	TOKENIZE_COLD: "tokenizeColdMs",
+	UPSTREAM_TTFB: "upstreamTtfbMs",
+	LIMITER_RETRIES: "limiterRetries"
+};
+const storage = new AsyncLocalStorage();
+/** Run `fn` with a fresh per-request timings store available ambiently. */
+function runWithTimings(fn) {
+	const timings = /* @__PURE__ */ new Map();
+	return storage.run(timings, () => fn(timings));
+}
+/** The current request's timings store, if running inside `runWithTimings`. */
+function getTimings() {
+	return storage.getStore();
+}
+/**
+* Add `ms` to the named phase on the current (or given) timings store.
+* Accumulates: the same phase recorded multiple times sums (e.g. tokenize
+* running several passes within one request). No-op when no store is active.
+*/
+function addTiming(phase, ms, store = storage.getStore()) {
+	if (!store) return;
+	store.set(phase, (store.get(phase) ?? 0) + ms);
+}
+/** Time a sync fn and accumulate its duration under `phase`; returns its result. */
+function timeSync(phase, fn) {
+	const start = performance.now();
+	try {
+		return fn();
+	} finally {
+		addTiming(phase, performance.now() - start);
+	}
+}
+/**
+* Project a collected timings Map onto the PhaseTimings shape so it can be
+* spread straight onto a tracker RequestUpdate. Values are rounded to whole ms
+* (limiterRetries is already integer, so rounding is a no-op there).
+*/
+function timingsToUpdate(timings) {
+	const out = {};
+	if (!timings) return out;
+	const writable = out;
+	for (const [key, value] of timings) writable[key] = Math.round(value);
+	return out;
+}
+
 //#endregion
 //#region src/lib/fetch-retry.ts
 const RETRYABLE_CAUSE_CODES = new Set([
@@ -517,7 +568,9 @@ async function fetchWithRetry(input, init, options) {
 	let networkAttempts = 0;
 	for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) try {
 		networkAttempts++;
+		const fetchStart = performance.now();
 		const response = await fetch(input, currentInit);
+		const ttfbMs = performance.now() - fetchStart;
 		if (response.status === 401 && !authRefreshed && options?.onUnauthorized) {
 			const refreshed = await tryRefreshAuth(options.onUnauthorized);
 			if (refreshed) {
@@ -529,6 +582,7 @@ async function fetchWithRetry(input, init, options) {
 				continue;
 			}
 		}
+		addTiming(TIMING.UPSTREAM_TTFB, ttfbMs);
 		annotateRetryMeta(response, networkAttempts, authRefreshed);
 		return response;
 	} catch (error) {
@@ -993,1183 +1047,329 @@ const logout = defineCommand({
 
 //#endregion
 //#region package.json
-var version = "0.12.0";
+var version = "0.13.1";
 
 //#endregion
-//#region src/lib/adaptive-rate-limiter.ts
-const DEFAULT_CONFIG$1 = {
-	baseRetryIntervalSeconds: 10,
-	maxRetryIntervalSeconds: 120,
-	requestIntervalSeconds: 10,
-	recoveryTimeoutMinutes: 10,
-	consecutiveSuccessesForRecovery: 5,
-	gradualRecoverySteps: [
-		5,
-		2,
-		1,
-		0
-	]
-};
-/**
-* Adaptive rate limiter that switches between normal, rate-limited, and recovering modes
-* based on API responses.
-*/
-var AdaptiveRateLimiter = class {
-	config;
-	mode = "normal";
-	queue = [];
-	processing = false;
-	rateLimitedAt = null;
-	consecutiveSuccesses = 0;
-	lastRequestTime = 0;
-	/** Current step in gradual recovery (index into gradualRecoverySteps) */
-	recoveryStepIndex = 0;
-	constructor(config = {}) {
-		this.config = {
-			...DEFAULT_CONFIG$1,
-			...config
-		};
-	}
-	/**
-	* Execute a request with adaptive rate limiting.
-	* Returns a promise that resolves when the request succeeds.
-	* The request will be retried automatically on 429 errors.
-	*/
-	async execute(fn) {
-		if (this.mode === "normal") return this.executeInNormalMode(fn);
-		if (this.mode === "recovering") return this.executeInRecoveringMode(fn);
-		return this.enqueue(fn);
-	}
-	/**
-	* Check if an error is a rate limit error (429) and extract Retry-After if available
-	*/
-	isRateLimitError(error) {
-		if (error && typeof error === "object") {
-			if ("status" in error && error.status === 429) return {
-				isRateLimit: true,
-				retryAfter: this.extractRetryAfter(error)
-			};
-			if ("responseText" in error && typeof error.responseText === "string") try {
-				const parsed = JSON.parse(error.responseText);
-				if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error && typeof parsed.error === "object" && "code" in parsed.error && parsed.error.code === "rate_limited") return { isRateLimit: true };
-			} catch {}
-		}
-		return { isRateLimit: false };
-	}
-	/**
-	* Extract Retry-After value from error response
-	*/
-	extractRetryAfter(error) {
-		if (!error || typeof error !== "object") return void 0;
-		if ("responseText" in error && typeof error.responseText === "string") try {
-			const parsed = JSON.parse(error.responseText);
-			if (parsed && typeof parsed === "object" && "retry_after" in parsed && typeof parsed.retry_after === "number") return parsed.retry_after;
-			if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error && typeof parsed.error === "object" && "retry_after" in parsed.error && typeof parsed.error.retry_after === "number") return parsed.error.retry_after;
-		} catch {}
-	}
-	/**
-	* Execute in normal mode - full speed
-	*/
-	async executeInNormalMode(fn) {
-		try {
-			return {
-				result: await fn(),
-				queueWaitMs: 0
-			};
-		} catch (error) {
-			const { isRateLimit, retryAfter } = this.isRateLimitError(error);
-			if (isRateLimit) {
-				this.enterRateLimitedMode();
-				return this.enqueue(fn, retryAfter);
-			}
-			throw error;
-		}
-	}
-	/**
-	* Execute in recovering mode - gradual speedup
-	*/
-	async executeInRecoveringMode(fn) {
-		const startTime = Date.now();
-		const currentInterval = this.config.gradualRecoverySteps[this.recoveryStepIndex] ?? 0;
-		if (currentInterval > 0) {
-			const elapsedMs = Date.now() - this.lastRequestTime;
-			const requiredMs = currentInterval * 1e3;
-			if (this.lastRequestTime > 0 && elapsedMs < requiredMs) {
-				const waitMs = requiredMs - elapsedMs;
-				await this.sleep(waitMs);
-			}
-		}
-		this.lastRequestTime = Date.now();
-		try {
-			const result = await fn();
-			this.recoveryStepIndex++;
-			if (this.recoveryStepIndex >= this.config.gradualRecoverySteps.length) this.completeRecovery();
-			else {
-				const nextInterval = this.config.gradualRecoverySteps[this.recoveryStepIndex] ?? 0;
-				consola.info(`[RateLimiter] Recovery step ${this.recoveryStepIndex}/${this.config.gradualRecoverySteps.length} (next interval: ${nextInterval}s)`);
-			}
-			return {
-				result,
-				queueWaitMs: Date.now() - startTime
-			};
-		} catch (error) {
-			const { isRateLimit, retryAfter } = this.isRateLimitError(error);
-			if (isRateLimit) {
-				consola.warn("[RateLimiter] Hit rate limit during recovery, returning to rate-limited mode");
-				this.enterRateLimitedMode();
-				return this.enqueue(fn, retryAfter);
-			}
-			throw error;
-		}
-	}
-	/**
-	* Enter rate-limited mode
-	*/
-	enterRateLimitedMode() {
-		if (this.mode === "rate-limited") return;
-		this.mode = "rate-limited";
-		this.rateLimitedAt = Date.now();
-		this.consecutiveSuccesses = 0;
-		consola.warn(`[RateLimiter] Entering rate-limited mode. Requests will be queued with exponential backoff (base: ${this.config.baseRetryIntervalSeconds}s).`);
-	}
-	/**
-	* Check if we should try to recover to normal mode
-	*/
-	shouldAttemptRecovery() {
-		if (this.consecutiveSuccesses >= this.config.consecutiveSuccessesForRecovery) {
-			consola.info(`[RateLimiter] ${this.consecutiveSuccesses} consecutive successes. Starting gradual recovery.`);
-			return true;
-		}
-		if (this.rateLimitedAt) {
-			if (Date.now() - this.rateLimitedAt >= this.config.recoveryTimeoutMinutes * 60 * 1e3) {
-				consola.info(`[RateLimiter] ${this.config.recoveryTimeoutMinutes} minutes elapsed. Starting gradual recovery.`);
-				return true;
-			}
-		}
-		return false;
-	}
-	/**
-	* Start gradual recovery mode
-	*/
-	startGradualRecovery() {
-		this.mode = "recovering";
-		this.recoveryStepIndex = 0;
-		this.rateLimitedAt = null;
-		this.consecutiveSuccesses = 0;
-		const firstInterval = this.config.gradualRecoverySteps[0] ?? 0;
-		consola.info(`[RateLimiter] Starting gradual recovery (${this.config.gradualRecoverySteps.length} steps, first interval: ${firstInterval}s)`);
-	}
-	/**
-	* Complete recovery to normal mode
-	*/
-	completeRecovery() {
-		this.mode = "normal";
-		this.recoveryStepIndex = 0;
-		consola.success("[RateLimiter] Recovery complete. Full speed enabled.");
-	}
-	/**
-	* Enqueue a request for later execution
-	*/
-	enqueue(fn, retryAfterSeconds) {
-		return new Promise((resolve, reject) => {
-			const request = {
-				execute: fn,
-				resolve,
-				reject,
-				retryCount: 0,
-				retryAfterSeconds,
-				enqueuedAt: Date.now()
-			};
-			this.queue.push(request);
-			if (this.queue.length > 1) {
-				const position = this.queue.length;
-				const estimatedWait = (position - 1) * this.config.requestIntervalSeconds;
-				consola.info(`[RateLimiter] Request queued (position ${position}, ~${estimatedWait}s wait)`);
-			}
-			this.processQueue();
-		});
-	}
-	/**
-	* Calculate retry interval with exponential backoff
-	*/
-	calculateRetryInterval(request) {
-		if (request.retryAfterSeconds !== void 0 && request.retryAfterSeconds > 0) return request.retryAfterSeconds;
-		const backoff = this.config.baseRetryIntervalSeconds * Math.pow(2, request.retryCount);
-		return Math.min(backoff, this.config.maxRetryIntervalSeconds);
-	}
-	/**
-	* Process the queue
-	*/
-	async processQueue() {
-		if (this.processing) return;
-		this.processing = true;
-		while (this.queue.length > 0) {
-			const request = this.queue[0];
-			if (this.shouldAttemptRecovery()) this.startGradualRecovery();
-			const elapsedMs = Date.now() - this.lastRequestTime;
-			const requiredMs = (request.retryCount > 0 ? this.calculateRetryInterval(request) : this.config.requestIntervalSeconds) * 1e3;
-			if (this.lastRequestTime > 0 && elapsedMs < requiredMs) {
-				const waitMs = requiredMs - elapsedMs;
-				const waitSec = Math.ceil(waitMs / 1e3);
-				consola.info(`[RateLimiter] Waiting ${waitSec}s before next request...`);
-				await this.sleep(waitMs);
-			}
-			this.lastRequestTime = Date.now();
-			try {
-				const result = await request.execute();
-				this.queue.shift();
-				this.consecutiveSuccesses++;
-				request.retryAfterSeconds = void 0;
-				const queueWaitMs = Date.now() - request.enqueuedAt;
-				request.resolve({
-					result,
-					queueWaitMs
-				});
-				if (this.mode === "rate-limited") consola.info(`[RateLimiter] Request succeeded (${this.consecutiveSuccesses}/${this.config.consecutiveSuccessesForRecovery} for recovery)`);
-			} catch (error) {
-				const { isRateLimit, retryAfter } = this.isRateLimitError(error);
-				if (isRateLimit) {
-					request.retryCount++;
-					request.retryAfterSeconds = retryAfter;
-					this.consecutiveSuccesses = 0;
-					this.rateLimitedAt = Date.now();
-					const nextInterval = this.calculateRetryInterval(request);
-					const source = retryAfter ? "server Retry-After" : "exponential backoff";
-					consola.warn(`[RateLimiter] Request failed with 429 (retry #${request.retryCount}). Retrying in ${nextInterval}s (${source})...`);
-				} else {
-					this.queue.shift();
-					request.reject(error);
-				}
-			}
-		}
-		this.processing = false;
-	}
-	sleep(ms) {
-		return new Promise((resolve) => setTimeout(resolve, ms));
-	}
-	/**
-	* Reject all currently queued requests during shutdown.
-	* Returns the number of requests that were rejected.
-	*/
-	rejectQueued() {
-		const count = this.queue.length;
-		for (const request of this.queue) request.reject(/* @__PURE__ */ new Error("Server is shutting down"));
-		this.queue = [];
-		return count;
-	}
-	/**
-	* Get current status for debugging/monitoring
-	*/
-	getStatus() {
-		return {
-			mode: this.mode,
-			queueLength: this.queue.length,
-			consecutiveSuccesses: this.consecutiveSuccesses,
-			rateLimitedAt: this.rateLimitedAt
-		};
+//#region src/lib/event-loop-lag.ts
+const PROBE_INTERVAL_MS = 500;
+const REPORT_EVERY = 20;
+const WARN_LAG_MS = 50;
+let timer$1 = null;
+let expectedNext = 0;
+let maxLagMs = 0;
+let sumLagMs = 0;
+let samples = 0;
+function startEventLoopLagMonitor() {
+	if (timer$1) return;
+	expectedNext = performance.now() + PROBE_INTERVAL_MS;
+	timer$1 = setInterval(() => {
+		const now = performance.now();
+		const lag = Math.max(0, now - expectedNext);
+		expectedNext = now + PROBE_INTERVAL_MS;
+		maxLagMs = Math.max(maxLagMs, lag);
+		sumLagMs += lag;
+		samples++;
+		if (samples < REPORT_EVERY) return;
+		const avg = sumLagMs / samples;
+		const max = maxLagMs;
+		if (max >= WARN_LAG_MS) consola.warn(`[event-loop] lag avg=${avg.toFixed(1)}ms max=${max.toFixed(1)}ms (blocked thread)`);
+		else consola.debug(`[event-loop] lag avg=${avg.toFixed(1)}ms max=${max.toFixed(1)}ms`);
+		maxLagMs = 0;
+		sumLagMs = 0;
+		samples = 0;
+	}, PROBE_INTERVAL_MS);
+	if (typeof timer$1.unref === "function") timer$1.unref();
+}
+function stopEventLoopLagMonitor() {
+	if (timer$1) {
+		clearInterval(timer$1);
+		timer$1 = null;
 	}
-};
-let rateLimiterInstance = null;
-/**
-* Initialize the adaptive rate limiter with configuration
-*/
-function initAdaptiveRateLimiter(config = {}) {
-	rateLimiterInstance = new AdaptiveRateLimiter(config);
-	const baseRetry = config.baseRetryIntervalSeconds ?? DEFAULT_CONFIG$1.baseRetryIntervalSeconds;
-	const maxRetry = config.maxRetryIntervalSeconds ?? DEFAULT_CONFIG$1.maxRetryIntervalSeconds;
-	const interval = config.requestIntervalSeconds ?? DEFAULT_CONFIG$1.requestIntervalSeconds;
-	const recovery = config.recoveryTimeoutMinutes ?? DEFAULT_CONFIG$1.recoveryTimeoutMinutes;
-	const successes = config.consecutiveSuccessesForRecovery ?? DEFAULT_CONFIG$1.consecutiveSuccessesForRecovery;
-	const steps = config.gradualRecoverySteps ?? DEFAULT_CONFIG$1.gradualRecoverySteps;
-	consola.info(`[RateLimiter] Initialized (backoff: ${baseRetry}s-${maxRetry}s, interval: ${interval}s, recovery: ${recovery}min or ${successes} successes, gradual: [${steps.join("s, ")}s])`);
-}
-/**
-* Get the rate limiter instance
-*/
-function getAdaptiveRateLimiter() {
-	return rateLimiterInstance;
-}
-/**
-* Execute a request with adaptive rate limiting.
-* If rate limiter is not initialized, executes immediately.
-* Returns the result along with queue wait time.
-*/
-async function executeWithAdaptiveRateLimit(fn) {
-	if (!rateLimiterInstance) return {
-		result: await fn(),
-		queueWaitMs: 0
-	};
-	return rateLimiterInstance.execute(fn);
 }
 
 //#endregion
-//#region src/lib/auth-gate.ts
-/**
-* Auth gate — the inbound authentication decision point for the proxy.
-*
-* Protects this proxy's *inbound* surface with a configured **Proxy API key**
-* (NOT the outbound GitHub OAuth token or Copilot token). The decision logic
-* is expressed as pure functions so it can be unit-tested without booting the
-* server or reaching upstream.
-*/
+//#region src/lib/history-ws.ts
 /**
-* Extract candidate presented credential values from request headers.
-*
-* Two header shapes are read, and **both** contribute candidates when present
-* (compare-all-present) so neither is silently ignored in favor of the other —
-* a later any-match over the candidates decides acceptance:
-*  - `Authorization`: the scheme prefix is stripped case-insensitively
-*    (`Bearer ` / `bearer ` …) because the scheme is case-insensitive per
-*    RFC 7235, while the secret itself is case-sensitive. A bare value with no
-*    scheme prefix is tolerated and returned verbatim.
-*  - `x-api-key` (Issue 02): the Anthropic-native header. Taken verbatim — no
-*    scheme stripping (a value that happens to start with `Bearer ` is kept
-*    as-is).
-*
-* Order is `[Authorization, x-api-key]` for any present header; absent headers
-* contribute nothing.
+* WebSocket support for History API.
+* Enables real-time updates when new requests are recorded.
 */
-function extractCredentials(headers) {
-	const candidates = [];
-	const authorization = headers.get("authorization");
-	if (authorization !== null) candidates.push(authorization.replace(/^Bearer\s+/i, ""));
-	const apiKey = headers.get("x-api-key");
-	if (apiKey !== null) candidates.push(apiKey);
-	return candidates;
+const clients = /* @__PURE__ */ new Set();
+function addClient(ws) {
+	clients.add(ws);
+	const msg = {
+		type: "connected",
+		data: { clientCount: clients.size },
+		timestamp: Date.now()
+	};
+	ws.send(JSON.stringify(msg));
 }
-/**
-* Hard-coded exemption set: the liveness (`/`) and readiness (`/health`)
-* endpoints are reachable without a key so container orchestration probes are
-* never blocked. Everything else is protected (fail-closed) — unknown / future
-* routes default to protected.
-*
-* Matching is by **exact path**, with a trailing slash tolerated (so `/health/`
-* is exempt too) and `/` itself handled explicitly. Prefix matching is
-* deliberately avoided: `/healthz` or `/health/extra` must NOT be exempt. The
-* server registers a matching `/health/` route, so an exempt `/health/` request
-* resolves to the readiness handler rather than 404ing.
-*/
-function isExemptPath(path) {
-	if (path === "/") return true;
-	return (path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path) === "/health";
+function removeClient(ws) {
+	clients.delete(ws);
 }
-/**
-* Compute the fixed-length sha256 digest (32 bytes) of the configured key.
-* The configured key is trimmed before hashing (config-side trim).
-*/
-function digestConfiguredKey(configuredKey) {
-	return createHash("sha256").update(configuredKey.trim()).digest();
+function getClientCount() {
+	return clients.size;
 }
-/**
-* Constant-time membership test: does any presented candidate match the
-* configured key?
-*
-* Each candidate is sha256'd to a fixed 32-byte digest and compared against the
-* configured digest. Hashing to a fixed length sidesteps the `RangeError` that
-* `crypto.timingSafeEqual` throws on length-mismatched buffers, so a
-* wrong-length presented value yields `false` rather than throwing.
-*/
-function matchesConfiguredKey(configuredDigest, candidates) {
-	return candidates.some((candidate) => {
-		return timingSafeEqual(createHash("sha256").update(candidate).digest(), configuredDigest);
+function closeAllClients() {
+	for (const client of clients) try {
+		client.close(1001, "Server shutting down");
+	} catch {}
+	clients.clear();
+}
+function broadcast(message) {
+	const data = JSON.stringify(message);
+	for (const client of clients) try {
+		if (client.readyState === WebSocket.OPEN) client.send(data);
+		else clients.delete(client);
+	} catch (error) {
+		consola.debug("WebSocket send failed, removing client:", error);
+		clients.delete(client);
+	}
+}
+function notifyEntryAdded(summary) {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "entry_added",
+		data: summary,
+		timestamp: Date.now()
 	});
 }
-/**
-* Resolve the inbound Proxy API key from its two operator-facing sources,
-* applying the precedence + normalization contract (Issue 03):
-*
-*  - `--api-key` flag (`flag`) and `COPILOT_API_KEY` env (`env`) are each
-*    **trimmed first**; a trimmed-empty source (`""`, whitespace, or
-*    `undefined`) counts as **not provided**.
-*  - When both provide a non-empty value, the **flag wins** (env ignored).
-*  - When only one provides a non-empty value, that one is used.
-*  - When neither does, `key` is `undefined` and `source` is `"none"` → auth
-*    stays disabled (same as the no-`--api-key` default).
-*
-* Pure: it reads nothing from `process.env` itself (the caller passes the env
-* value in), so it is fully unit-testable and the precedence logic is decoupled
-* from how the values are sourced.
-*/
-function resolveProxyApiKey(sources) {
-	const flag = sources.flag?.trim() ?? "";
-	if (flag !== "") return {
-		key: flag,
-		source: "flag"
-	};
-	const env = sources.env?.trim() ?? "";
-	if (env !== "") return {
-		key: env,
-		source: "env"
-	};
-	return {
-		key: void 0,
-		source: "none"
-	};
-}
-/**
-* Resolve the hostname the server will *actually* bind to, decided at the CLI
-* edge with flag-over-env precedence and a **safe loopback default** — the same
-* flag-over-env shape this codebase already uses to reconcile a CLI flag with
-* its env twin (`--api-key`/`COPILOT_API_KEY`, `--github-token`/`GH_TOKEN`).
-*
-*  - `--host` flag wins when present; otherwise the `HOST` env; otherwise the
-*    default `127.0.0.1`.
-*  - The default is **loopback, not all-interfaces**: an unconfigured instance
-*    must not expose `/token` (which echoes the plaintext Copilot token) and the
-*    otherwise-unauthenticated API to the whole network. Binding every interface
-*    is now an explicit opt-in — pass `--host 0.0.0.0` (or `HOST=0.0.0.0`).
-*  - **flag vs env asymmetry on a blank value** (the security-critical part): an
-*    explicit `--host` flag is the operator's deliberate choice, so a blank flag
-*    (`--host ""` / whitespace) is taken as the wildcard-bind escape hatch and
-*    canonicalized to an explicit `0.0.0.0` (rather than left as `""` to lean on
-*    srvx's undocumented empty-string handling). But a *set-but-blank* `HOST` env
-*    (`HOST=`, or `HOST=$UNSET` in a shell / compose where the var is unset →
-*    empty — NOT a deliberate keystroke) is accidental plumbing, so it is treated
-*    as **not provided** and falls through to the loopback default. This mirrors
-*    `resolveProxyApiKey` trimming `""` to not-provided, so an empty `HOST` can't
-*    silently reopen the all-interfaces-unauthenticated exposure the loopback
-*    default exists to prevent.
-*  - **Both sources are trimmed**: a padded `--host " 10.0.0.5 "` or
-*    `HOST=" 10.0.0.5 "` would otherwise reach the socket bind verbatim and fail
-*    with `ENOTFOUND`. Trimming also decides blank-ness for the rules above.
-*
-* `env` is passed in (not read here) to keep the function pure and unit-testable.
-*/
-function resolveBindHost(flag, env) {
-	if (flag !== void 0) {
-		const trimmed = flag.trim();
-		return trimmed === "" ? "0.0.0.0" : trimmed;
-	}
-	const envTrimmed = env?.trim() ?? "";
-	if (envTrimmed !== "") return envTrimmed;
-	return "127.0.0.1";
-}
-/**
-* Resolve the address the server will *actually* bind to for the startup banner
-* (Issue 04).
-*
-* Mirrors srvx's own host resolution EXACTLY so the banner reports the TRUE bind
-* rather than a guess that could diverge from what srvx passes to the runtime.
-* srvx computes `hostname = opts.hostname ?? process.env.HOST` (a raw nullish
-* coalesce — no trimming, no empty-string special-casing), and start.ts passes
-* `hostname: options.host`. So:
-*   - an explicit `--host` (even `""` / whitespace) is what srvx uses verbatim —
-*     it does NOT fall back to HOST once `opts.hostname` is a non-null string;
-*   - only an absent (`undefined`) `--host` lets srvx fall back to `HOST`;
-*   - when the coalesced value is `undefined` or empty, the runtime binds all
-*     interfaces, which we report as the explicit `0.0.0.0` so a wide-open bind
-*     is unmistakable (srvx renders the same bind as "localhost (all
-*     interfaces)").
-*
-* Critically, the resolved non-empty value is returned VERBATIM (not trimmed):
-* srvx hands the runtime exactly that string, so the banner must report exactly
-* that string — trimming here would make the banner claim a different address
-* than the one actually bound. `env` is passed in (not read) to keep the
-* function pure and unit-testable.
-*/
-function resolveBindAddress(host, env) {
-	const resolved = host ?? env;
-	if (resolved === void 0 || resolved === "") return "0.0.0.0";
-	return resolved;
+function notifyEntryUpdated(summary) {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "entry_updated",
+		data: summary,
+		timestamp: Date.now()
+	});
 }
-/**
-* Resolve the CLIENT-FACING host for generated configs and viewer links
-* (Issue 04), derived from the SAME srvx host resolution as the banner so the
-* two never disagree about what was bound — and formatted as a valid URL
-* authority so the links actually parse.
-*
-* Two differences from {@link resolveBindAddress}:
-*  - All-interfaces rendering: a wildcard bind (`0.0.0.0` / `::` / `[::]` /
-*    empty) is not a connectable target, so it maps to `localhost` for URLs a
-*    client will actually dial (matching srvx's "localhost (all interfaces)"
-*    presentation). A narrowed bind (e.g. `127.0.0.1`, `192.168.1.10`, an IPv6
-*    address) is kept so generated links point at the real interface — fixing
-*    the prior bug where setting `HOST` (with `--host` omitted) yielded
-*    `http://localhost:<port>` links the narrowed bind wasn't listening on.
-*  - IPv6 bracketing: a literal IPv6 host (contains `:`) is wrapped in `[...]`,
-*    exactly as srvx's own `fmtURL` does, so `http://[2001:db8::1]:<port>` is a
-*    valid authority rather than the unparseable `http://2001:db8::1:<port>`.
-*
-* Returns a host token ready to drop into `http://<token>:<port>`.
-*/
-function resolveClientHost(host, env) {
-	const bind = resolveBindAddress(host, env);
-	if (bind === "0.0.0.0" || bind === "::" || bind === "[::]") return "localhost";
-	if (bind.includes(":") && !bind.startsWith("[")) return `[${bind}]`;
-	return bind;
+function notifyStatsUpdated(stats) {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "stats_updated",
+		data: stats,
+		timestamp: Date.now()
+	});
 }
-/**
-* Build the inbound-auth startup banner lines (Issue 04).
-*
-* Returns the human-readable lines the proxy prints at boot so operators can see,
-* at a glance, the security posture of *this* instance:
-*  - auth ON  → `认证开启`, plus the key's origin (`flag` / `env`), plus the real
-*    bind address.
-*  - auth OFF → `认证关闭`, plus the real bind address (so a careless all-
-*    interfaces bind without auth is visible).
-*
-* The configured key value is **never** an input here, so it can never leak into
-* the banner — the function only knows the *source* tag, not the secret. Pure
-* (string in → strings out) so the banner copy is pinned by unit tests.
-*/
-function buildStartupAuthLines(params) {
-	const { source, bindAddress } = params;
-	return [source === "none" ? `Inbound auth: 认证关闭 (no proxy API key configured)` : `Inbound auth: 认证开启 (source: ${source})`, `Binding to: ${bindAddress}`];
+function notifyHistoryCleared() {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "history_cleared",
+		data: null,
+		timestamp: Date.now()
+	});
 }
-/**
-* Configure the proxy API key on global state from a raw configured value.
-*
-* The value is trimmed; a trimmed-empty value (or `undefined`) is treated as
-* "not provided" → auth stays disabled. Otherwise the precomputed digest is
-* stored on state (presence === enabled). Returns whether auth is enabled.
-*
-* The `--api-key` flag and `COPILOT_API_KEY` env source are reconciled upstream
-* by `resolveProxyApiKey` (flag-over-env precedence, Issue 03); this function
-* receives only the already-resolved value.
-*/
-function configureProxyApiKey(rawKey) {
-	const trimmed = rawKey?.trim() ?? "";
-	if (trimmed === "") {
-		state.proxyApiKeyDigest = void 0;
-		return false;
-	}
-	state.proxyApiKeyDigest = digestConfiguredKey(trimmed);
-	return true;
+function notifySessionDeleted(sessionId) {
+	if (clients.size === 0) return;
+	broadcast({
+		type: "session_deleted",
+		data: { sessionId },
+		timestamp: Date.now()
+	});
 }
-/**
-* Path → auth-family selector (Issue 02).
-*
-* The Anthropic-native surface is `/v1/messages` and its `count_tokens`
-* subpath; both map to the Anthropic family so a native Anthropic client gets
-* the `authentication_error` body. Everything else — including every other
-* `/v1/…` endpoint and any unknown / future route — defaults to the OpenAI
-* family.
-*
-* Matching is by **exact path** (a trailing slash tolerated), deliberately not
-* a prefix test: the shared `/v1/` prefix must not sweep OpenAI-style endpoints
-* into the Anthropic family, and `/v1/messages-extra` or a deeper unexpected
-* subpath must not be misclassified either. This mirrors `isExemptPath`'s
-* exact-with-trailing-slash convention.
-*/
-function selectFamily(path) {
-	const normalized = path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
-	if (normalized === "/v1/messages" || normalized === "/v1/messages/count_tokens") return "anthropic";
-	return "openai";
+
+//#endregion
+//#region src/lib/history.ts
+function generateId$1() {
+	return Date.now().toString(36) + Math.random().toString(36).slice(2, 9);
 }
-/**
-* OpenAI-family 401 response body. The literal field values are pinned by the
-* ADR so OpenAI-compatible SDKs recognize the failure as an auth error. The
-* same body is returned whether credentials were missing or wrong (no oracle).
-*/
-function unauthorizedOpenAIBody() {
-	return { error: {
-		message: "Invalid API key provided.",
-		type: "invalid_request_error",
-		code: "invalid_api_key",
-		param: null
-	} };
+const historyState = {
+	enabled: false,
+	entries: [],
+	sessions: /* @__PURE__ */ new Map(),
+	currentSessionId: "",
+	maxEntries: 1e3,
+	sessionTimeoutMs: 1800 * 1e3
+};
+const entryIndex = /* @__PURE__ */ new Map();
+function initHistory(enabled, maxEntries) {
+	historyState.enabled = enabled;
+	historyState.maxEntries = maxEntries;
+	historyState.entries = [];
+	historyState.sessions = /* @__PURE__ */ new Map();
+	historyState.currentSessionId = enabled ? generateId$1() : "";
+	entryIndex.clear();
 }
-/**
-* Anthropic-family 401 response body (Issue 02). Shape is pinned so Anthropic
-* SDKs (and Claude Code via `/v1/messages`) recognize the failure as an auth
-* error: a top-level `{type:"error", error:{type:"authentication_error",
-* message}}`. As with the OpenAI body, missing and wrong credentials return the
-* identical body (no oracle).
-*/
-function unauthorizedAnthropicBody() {
-	return {
-		type: "error",
-		error: {
-			type: "authentication_error",
-			message: "Invalid API key provided."
-		}
-	};
+function isHistoryEnabled() {
+	return historyState.enabled;
 }
-/**
-* Global fail-closed authentication middleware.
-*
-* Registered after the request logger and CORS but before route dispatch.
-* Behavior:
-*  - Disabled (no configured digest) → pass through unchanged (default).
-*  - Exempt path (`/`, `/health`) → pass through.
-*  - CORS preflight `OPTIONS` on a protected path → pass through so browser
-*    preflight isn't mistaken for a 401 (blocking it surfaces as an opaque CORS
-*    error, very hard to diagnose). Scoped to *actual* preflights — an
-*    `OPTIONS` carrying `Access-Control-Request-Method` — rather than any
-*    `OPTIONS`, so the bypass surface can't silently widen. Preflights carry no
-*    protected payload, so this doesn't weaken fail-closed.
-*  - Otherwise require a valid Proxy API key; on failure return 401 with a
-*    `WWW-Authenticate: Bearer` header and a **family-appropriate** body —
-*    Anthropic-family (`/v1/messages*`) gets the `authentication_error` shape,
-*    everything else the OpenAI `invalid_api_key` shape (Issue 02). The family
-*    only selects the body shape; it does not change what is protected. Missing
-*    and wrong credentials return the field-identical body for that family.
-*/
-function authGate() {
-	return async (c, next) => {
-		const configuredDigest = state.proxyApiKeyDigest;
-		if (!configuredDigest) return next();
-		if (isExemptPath(c.req.path)) return next();
-		if (c.req.method === "OPTIONS" && c.req.raw.headers.get("access-control-request-method") !== null) return next();
-		if (matchesConfiguredKey(configuredDigest, extractCredentials(c.req.raw.headers))) return next();
-		c.header("WWW-Authenticate", "Bearer");
-		if (selectFamily(c.req.path) === "anthropic") return c.json(unauthorizedAnthropicBody(), 401);
-		return c.json(unauthorizedOpenAIBody(), 401);
-	};
-}
-
-//#endregion
-//#region src/lib/context/request.ts
-let idCounter = 0;
-function createRequestContext(opts) {
-	const id = `req_${Date.now()}_${++idCounter}`;
-	const startTime = Date.now();
-	const onEvent = opts.onEvent;
-	let _state = "pending";
-	let _originalRequest = null;
-	let _response = null;
-	let settled = false;
-	function emit(event) {
-		try {
-			onEvent(event);
-		} catch {}
-	}
-	const ctx = {
-		id,
-		tuiLogId: opts.tuiLogId,
-		startTime,
-		endpoint: opts.endpoint,
-		get state() {
-			return _state;
-		},
-		get durationMs() {
-			return Date.now() - startTime;
-		},
-		get settled() {
-			return settled;
-		},
-		get originalRequest() {
-			return _originalRequest;
-		},
-		get response() {
-			return _response;
-		},
-		setOriginalRequest(req) {
-			_originalRequest = req;
-			emit({
-				type: "updated",
-				context: ctx,
-				field: "originalRequest"
-			});
-		},
-		transition(newState) {
-			const previousState = _state;
-			_state = newState;
-			emit({
-				type: "state_changed",
-				context: ctx,
-				previousState
-			});
-		},
-		complete(response) {
-			if (settled) return;
-			settled = true;
-			_response = response;
-			_state = "completed";
-			emit({
-				type: "completed",
-				context: ctx,
-				entry: ctx.toHistoryEntry()
-			});
-		},
-		fail(model, error) {
-			if (settled) return;
-			settled = true;
-			_response = {
-				success: false,
-				model,
-				usage: {
-					input_tokens: 0,
-					output_tokens: 0
-				},
-				error: error instanceof Error ? error.message : String(error),
-				content: null
-			};
-			_state = "failed";
-			emit({
-				type: "failed",
-				context: ctx,
-				entry: ctx.toHistoryEntry()
-			});
-		},
-		toHistoryEntry() {
-			const entry = {
-				id,
-				endpoint: opts.endpoint,
-				timestamp: startTime,
-				durationMs: Date.now() - startTime,
-				request: {
-					model: _originalRequest?.model,
-					messages: _originalRequest?.messages,
-					stream: _originalRequest?.stream,
-					tools: _originalRequest?.tools,
-					system: _originalRequest?.system
-				}
-			};
-			if (_response) entry.response = _response;
-			return entry;
+function getCurrentSession(endpoint) {
+	const now = Date.now();
+	if (historyState.currentSessionId) {
+		const session = historyState.sessions.get(historyState.currentSessionId);
+		if (session && now - session.lastActivity < historyState.sessionTimeoutMs) {
+			session.lastActivity = now;
+			return historyState.currentSessionId;
 		}
-	};
-	return ctx;
-}
-
-//#endregion
-//#region src/lib/context/manager.ts
-/**
-* RequestContextManager — Active request management
-*
-* Manages all in-flight RequestContext instances. Publishes events for
-* WebSocket push and history persistence.
-*/
-let _manager = null;
-function initRequestContextManager(staleMaxAgeSec) {
-	_manager = createRequestContextManager(staleMaxAgeSec);
-	return _manager;
+	}
+	const sessionId = generateId$1();
+	historyState.currentSessionId = sessionId;
+	historyState.sessions.set(sessionId, {
+		id: sessionId,
+		startTime: now,
+		lastActivity: now,
+		requestCount: 0,
+		totalInputTokens: 0,
+		totalOutputTokens: 0,
+		models: [],
+		endpoint
+	});
+	return sessionId;
 }
-const REAPER_INTERVAL_MS = 6e4;
-const DEFAULT_STALE_MAX_AGE_SEC = 600;
-function createRequestContextManager(staleMaxAgeSec) {
-	const maxAgeSec = staleMaxAgeSec ?? DEFAULT_STALE_MAX_AGE_SEC;
-	const activeContexts = /* @__PURE__ */ new Map();
-	const listeners = /* @__PURE__ */ new Set();
-	let reaperTimer = null;
-	function runReaperOnce() {
-		if (maxAgeSec <= 0) return;
-		const maxAgeMs = maxAgeSec * 1e3;
-		for (const [id, ctx] of activeContexts) if (ctx.durationMs > maxAgeMs) {
-			consola.warn(`[context] Force-failing stale request ${id} (endpoint: ${ctx.endpoint}, model: ${ctx.originalRequest?.model ?? "unknown"}, state: ${ctx.state}, age: ${Math.round(ctx.durationMs / 1e3)}s, max: ${maxAgeSec}s)`);
-			ctx.fail(ctx.originalRequest?.model ?? "unknown", /* @__PURE__ */ new Error(`Request exceeded maximum age of ${maxAgeSec}s (stale context reaper)`));
+function recordRequest(endpoint, request) {
+	if (!historyState.enabled) return "";
+	const sessionId = getCurrentSession(endpoint);
+	const session = historyState.sessions.get(sessionId);
+	if (!session) return "";
+	const entry = {
+		id: generateId$1(),
+		sessionId,
+		timestamp: Date.now(),
+		endpoint,
+		request: {
+			model: request.model,
+			messages: request.messages,
+			stream: request.stream,
+			tools: request.tools,
+			max_tokens: request.max_tokens,
+			temperature: request.temperature,
+			system: request.system
 		}
+	};
+	historyState.entries.push(entry);
+	entryIndex.set(entry.id, entry);
+	session.requestCount++;
+	if (!session.models.includes(request.model)) session.models.push(request.model);
+	if (request.tools && request.tools.length > 0) {
+		if (!session.toolsUsed) session.toolsUsed = [];
+		for (const tool of request.tools) if (!session.toolsUsed.includes(tool.name)) session.toolsUsed.push(tool.name);
 	}
-	function startReaper() {
-		if (reaperTimer) return;
-		reaperTimer = setInterval(runReaperOnce, REAPER_INTERVAL_MS);
+	while (historyState.maxEntries > 0 && historyState.entries.length > historyState.maxEntries) {
+		const removed = historyState.entries.shift();
+		if (removed) {
+			entryIndex.delete(removed.id);
+			if (historyState.entries.filter((e) => e.sessionId === removed.sessionId).length === 0) historyState.sessions.delete(removed.sessionId);
+		}
 	}
-	function stopReaper() {
-		if (reaperTimer) {
-			clearInterval(reaperTimer);
-			reaperTimer = null;
+	notifyEntryAdded({
+		id: entry.id,
+		endpoint,
+		model: request.model,
+		stream: request.stream,
+		timestamp: entry.timestamp
+	});
+	return entry.id;
+}
+function recordResponse(id, response, durationMs) {
+	if (!historyState.enabled || !id) return;
+	const entry = entryIndex.get(id);
+	if (entry) {
+		entry.response = response;
+		entry.durationMs = durationMs;
+		const session = historyState.sessions.get(entry.sessionId);
+		if (session) {
+			session.totalInputTokens += response.usage.input_tokens;
+			session.totalOutputTokens += response.usage.output_tokens;
+			session.lastActivity = Date.now();
 		}
+		notifyEntryUpdated({
+			id: entry.id,
+			endpoint: entry.endpoint,
+			model: response.model,
+			success: response.success,
+			durationMs,
+			inputTokens: response.usage.input_tokens,
+			outputTokens: response.usage.output_tokens
+		});
+		notifyStatsUpdated({
+			totalRequests: historyState.entries.length,
+			totalInputTokens: session?.totalInputTokens ?? 0,
+			totalOutputTokens: session?.totalOutputTokens ?? 0
+		});
 	}
-	function emit(event) {
-		for (const listener of listeners) try {
-			listener(event);
-		} catch {}
+}
+function getHistory(options = {}) {
+	const { page = 1, limit = 50, model, endpoint, status, from, to, search, sessionId } = options;
+	let filtered = [...historyState.entries];
+	if (sessionId) filtered = filtered.filter((e) => e.sessionId === sessionId);
+	if (model) {
+		const modelLower = model.toLowerCase();
+		filtered = filtered.filter((e) => e.request.model.toLowerCase().includes(modelLower) || e.response?.model.toLowerCase().includes(modelLower));
 	}
-	function handleContextEvent(rawEvent) {
-		const { type, context } = rawEvent;
-		switch (type) {
-			case "state_changed":
-				if (rawEvent.previousState) emit({
-					type: "state_changed",
-					context,
-					previousState: rawEvent.previousState
-				});
-				break;
-			case "updated":
-				if (rawEvent.field) emit({
-					type: "updated",
-					context,
-					field: rawEvent.field
-				});
-				break;
-			case "completed":
-				if (rawEvent.entry) emit({
-					type: "completed",
-					context,
-					entry: rawEvent.entry
-				});
-				activeContexts.delete(context.id);
-				break;
-			case "failed":
-				if (rawEvent.entry) emit({
-					type: "failed",
-					context,
-					entry: rawEvent.entry
-				});
-				activeContexts.delete(context.id);
-				break;
-			default: break;
-		}
+	if (endpoint) filtered = filtered.filter((e) => e.endpoint === endpoint);
+	let effectiveStatus = status;
+	const legacySuccess = options.success;
+	if (!effectiveStatus && legacySuccess !== void 0) effectiveStatus = legacySuccess ? "success" : "error";
+	switch (effectiveStatus) {
+		case "success":
+			filtered = filtered.filter((e) => e.response?.success === true);
+			break;
+		case "error":
+			filtered = filtered.filter((e) => e.response !== void 0 && !e.response.success);
+			break;
+		case "pending":
+			filtered = filtered.filter((e) => !e.response);
+			break;
+		default: break;
 	}
-	return {
-		create(opts) {
-			const ctx = createRequestContext({
-				endpoint: opts.endpoint,
-				tuiLogId: opts.tuiLogId,
-				onEvent: handleContextEvent
-			});
-			activeContexts.set(ctx.id, ctx);
-			emit({
-				type: "created",
-				context: ctx
+	if (from) filtered = filtered.filter((e) => e.timestamp >= from);
+	if (to) filtered = filtered.filter((e) => e.timestamp <= to);
+	if (search) {
+		const searchLower = search.toLowerCase();
+		filtered = filtered.filter((e) => {
+			const msgMatch = e.request.messages.some((m) => {
+				if (typeof m.content === "string") return m.content.toLowerCase().includes(searchLower);
+				if (Array.isArray(m.content)) return m.content.some((c) => c.text && c.text.toLowerCase().includes(searchLower));
+				return false;
 			});
-			return ctx;
-		},
-		get(id) {
-			return activeContexts.get(id);
-		},
-		getAll() {
-			return Array.from(activeContexts.values());
-		},
-		get activeCount() {
-			return activeContexts.size;
-		},
-		on(_event, listener) {
-			listeners.add(listener);
-		},
-		off(_event, listener) {
-			listeners.delete(listener);
-		},
-		startReaper,
-		stopReaper,
-		_runReaperOnce: runReaperOnce
+			const respMatch = e.response?.content && typeof e.response.content.content === "string" && e.response.content.content.toLowerCase().includes(searchLower);
+			const toolMatch = e.response?.toolCalls?.some((t) => t.name.toLowerCase().includes(searchLower));
+			const sysMatch = e.request.system?.toLowerCase().includes(searchLower);
+			return msgMatch || respMatch || toolMatch || sysMatch;
+		});
+	}
+	filtered.sort((a, b) => b.timestamp - a.timestamp);
+	const total = filtered.length;
+	const totalPages = Math.ceil(total / limit);
+	const start = (page - 1) * limit;
+	return {
+		entries: filtered.slice(start, start + limit),
+		total,
+		page,
+		limit,
+		totalPages
 	};
 }
-
-//#endregion
-//#region src/lib/hidden-models.ts
-/**
-* Hardcoded list of GitHub Copilot model ids that are hidden from listing
-* endpoints (the /v1/models response, the startup ASCII banner, and the
-* --claude-code interactive prompts), unless `--show-all-models` is passed.
-*
-* Note: this is a DISPLAY filter only. Explicit POSTs to handler endpoints
-* with a hidden id are NOT rejected — they pass through to upstream verbatim.
-*
-* Bumping the list requires a code change + release. No env var, no config
-* file, no CLI append interface.
-*/
-const HIDDEN_MODEL_IDS = new Set([
-	"gpt-3.5-turbo",
-	"gpt-3.5-turbo-0613",
-	"gpt-4",
-	"gpt-4-0613",
-	"gpt-4-0125-preview",
-	"gpt-4o",
-	"gpt-4o-mini",
-	"gpt-4-o-preview",
-	"gpt-4o-2024-05-13",
-	"gpt-4o-2024-08-06",
-	"gpt-4o-2024-11-20",
-	"gpt-4o-mini-2024-07-18",
-	"gpt-4.1",
-	"gpt-4.1-2025-04-14",
-	"gpt-41-copilot",
-	"gpt-5-mini",
-	"gpt-5.3-codex",
-	"gpt-5.4",
-	"text-embedding-ada-002",
-	"text-embedding-3-small",
-	"text-embedding-3-small-inference",
-	"gemini-2.5-pro",
-	"gemini-3-flash-preview",
-	"claude-opus-4.5",
-	"claude-opus-4.6",
-	"claude-opus-4.7-high",
-	"claude-opus-4.7-xhigh",
-	"claude-sonnet-4.5",
-	"mai-code-1-flash-internal",
-	"trajectory-compaction"
-]);
-function isHiddenModel(id, showAll) {
-	if (showAll) return false;
-	return HIDDEN_MODEL_IDS.has(id);
+function getEntry(id) {
+	return entryIndex.get(id);
 }
-
-//#endregion
-//#region src/lib/history-ws.ts
-/**
-* WebSocket support for History API.
-* Enables real-time updates when new requests are recorded.
-*/
-const clients = /* @__PURE__ */ new Set();
-function addClient(ws) {
-	clients.add(ws);
-	const msg = {
-		type: "connected",
-		data: { clientCount: clients.size },
-		timestamp: Date.now()
+function getSessions() {
+	const sessions = Array.from(historyState.sessions.values()).sort((a, b) => b.lastActivity - a.lastActivity);
+	return {
+		sessions,
+		total: sessions.length
 	};
-	ws.send(JSON.stringify(msg));
-}
-function removeClient(ws) {
-	clients.delete(ws);
-}
-function getClientCount() {
-	return clients.size;
-}
-function closeAllClients() {
-	for (const client of clients) try {
-		client.close(1001, "Server shutting down");
-	} catch {}
-	clients.clear();
-}
-function broadcast(message) {
-	const data = JSON.stringify(message);
-	for (const client of clients) try {
-		if (client.readyState === WebSocket.OPEN) client.send(data);
-		else clients.delete(client);
-	} catch (error) {
-		consola.debug("WebSocket send failed, removing client:", error);
-		clients.delete(client);
-	}
 }
-function notifyEntryAdded(summary) {
-	if (clients.size === 0) return;
-	broadcast({
-		type: "entry_added",
-		data: summary,
-		timestamp: Date.now()
-	});
+function getSession(id) {
+	return historyState.sessions.get(id);
 }
-function notifyEntryUpdated(summary) {
-	if (clients.size === 0) return;
-	broadcast({
-		type: "entry_updated",
-		data: summary,
-		timestamp: Date.now()
-	});
+function getSessionEntries(sessionId) {
+	return historyState.entries.filter((e) => e.sessionId === sessionId).sort((a, b) => a.timestamp - b.timestamp);
 }
-function notifyStatsUpdated(stats) {
-	if (clients.size === 0) return;
-	broadcast({
-		type: "stats_updated",
-		data: stats,
-		timestamp: Date.now()
-	});
+function clearHistory() {
+	historyState.entries = [];
+	historyState.sessions = /* @__PURE__ */ new Map();
+	historyState.currentSessionId = generateId$1();
+	entryIndex.clear();
+	notifyHistoryCleared();
 }
-function notifyHistoryCleared() {
-	if (clients.size === 0) return;
-	broadcast({
-		type: "history_cleared",
-		data: null,
-		timestamp: Date.now()
-	});
-}
-function notifySessionDeleted(sessionId) {
-	if (clients.size === 0) return;
-	broadcast({
-		type: "session_deleted",
-		data: { sessionId },
-		timestamp: Date.now()
-	});
-}
-
-//#endregion
-//#region src/lib/history.ts
-function generateId$1() {
-	return Date.now().toString(36) + Math.random().toString(36).slice(2, 9);
-}
-const historyState = {
-	enabled: false,
-	entries: [],
-	sessions: /* @__PURE__ */ new Map(),
-	currentSessionId: "",
-	maxEntries: 1e3,
-	sessionTimeoutMs: 1800 * 1e3
-};
-const entryIndex = /* @__PURE__ */ new Map();
-function initHistory(enabled, maxEntries) {
-	historyState.enabled = enabled;
-	historyState.maxEntries = maxEntries;
-	historyState.entries = [];
-	historyState.sessions = /* @__PURE__ */ new Map();
-	historyState.currentSessionId = enabled ? generateId$1() : "";
-	entryIndex.clear();
-}
-function isHistoryEnabled() {
-	return historyState.enabled;
-}
-function getCurrentSession(endpoint) {
-	const now = Date.now();
-	if (historyState.currentSessionId) {
-		const session = historyState.sessions.get(historyState.currentSessionId);
-		if (session && now - session.lastActivity < historyState.sessionTimeoutMs) {
-			session.lastActivity = now;
-			return historyState.currentSessionId;
-		}
-	}
-	const sessionId = generateId$1();
-	historyState.currentSessionId = sessionId;
-	historyState.sessions.set(sessionId, {
-		id: sessionId,
-		startTime: now,
-		lastActivity: now,
-		requestCount: 0,
-		totalInputTokens: 0,
-		totalOutputTokens: 0,
-		models: [],
-		endpoint
-	});
-	return sessionId;
-}
-function recordRequest(endpoint, request) {
-	if (!historyState.enabled) return "";
-	const sessionId = getCurrentSession(endpoint);
-	const session = historyState.sessions.get(sessionId);
-	if (!session) return "";
-	const entry = {
-		id: generateId$1(),
-		sessionId,
-		timestamp: Date.now(),
-		endpoint,
-		request: {
-			model: request.model,
-			messages: request.messages,
-			stream: request.stream,
-			tools: request.tools,
-			max_tokens: request.max_tokens,
-			temperature: request.temperature,
-			system: request.system
-		}
-	};
-	historyState.entries.push(entry);
-	entryIndex.set(entry.id, entry);
-	session.requestCount++;
-	if (!session.models.includes(request.model)) session.models.push(request.model);
-	if (request.tools && request.tools.length > 0) {
-		if (!session.toolsUsed) session.toolsUsed = [];
-		for (const tool of request.tools) if (!session.toolsUsed.includes(tool.name)) session.toolsUsed.push(tool.name);
-	}
-	while (historyState.maxEntries > 0 && historyState.entries.length > historyState.maxEntries) {
-		const removed = historyState.entries.shift();
-		if (removed) {
-			entryIndex.delete(removed.id);
-			if (historyState.entries.filter((e) => e.sessionId === removed.sessionId).length === 0) historyState.sessions.delete(removed.sessionId);
-		}
-	}
-	notifyEntryAdded({
-		id: entry.id,
-		endpoint,
-		model: request.model,
-		stream: request.stream,
-		timestamp: entry.timestamp
-	});
-	return entry.id;
-}
-function recordResponse(id, response, durationMs) {
-	if (!historyState.enabled || !id) return;
-	const entry = entryIndex.get(id);
-	if (entry) {
-		entry.response = response;
-		entry.durationMs = durationMs;
-		const session = historyState.sessions.get(entry.sessionId);
-		if (session) {
-			session.totalInputTokens += response.usage.input_tokens;
-			session.totalOutputTokens += response.usage.output_tokens;
-			session.lastActivity = Date.now();
-		}
-		notifyEntryUpdated({
-			id: entry.id,
-			endpoint: entry.endpoint,
-			model: response.model,
-			success: response.success,
-			durationMs,
-			inputTokens: response.usage.input_tokens,
-			outputTokens: response.usage.output_tokens
-		});
-		notifyStatsUpdated({
-			totalRequests: historyState.entries.length,
-			totalInputTokens: session?.totalInputTokens ?? 0,
-			totalOutputTokens: session?.totalOutputTokens ?? 0
-		});
-	}
-}
-function getHistory(options = {}) {
-	const { page = 1, limit = 50, model, endpoint, status, from, to, search, sessionId } = options;
-	let filtered = [...historyState.entries];
-	if (sessionId) filtered = filtered.filter((e) => e.sessionId === sessionId);
-	if (model) {
-		const modelLower = model.toLowerCase();
-		filtered = filtered.filter((e) => e.request.model.toLowerCase().includes(modelLower) || e.response?.model.toLowerCase().includes(modelLower));
-	}
-	if (endpoint) filtered = filtered.filter((e) => e.endpoint === endpoint);
-	let effectiveStatus = status;
-	const legacySuccess = options.success;
-	if (!effectiveStatus && legacySuccess !== void 0) effectiveStatus = legacySuccess ? "success" : "error";
-	switch (effectiveStatus) {
-		case "success":
-			filtered = filtered.filter((e) => e.response?.success === true);
-			break;
-		case "error":
-			filtered = filtered.filter((e) => e.response !== void 0 && !e.response.success);
-			break;
-		case "pending":
-			filtered = filtered.filter((e) => !e.response);
-			break;
-		default: break;
-	}
-	if (from) filtered = filtered.filter((e) => e.timestamp >= from);
-	if (to) filtered = filtered.filter((e) => e.timestamp <= to);
-	if (search) {
-		const searchLower = search.toLowerCase();
-		filtered = filtered.filter((e) => {
-			const msgMatch = e.request.messages.some((m) => {
-				if (typeof m.content === "string") return m.content.toLowerCase().includes(searchLower);
-				if (Array.isArray(m.content)) return m.content.some((c) => c.text && c.text.toLowerCase().includes(searchLower));
-				return false;
-			});
-			const respMatch = e.response?.content && typeof e.response.content.content === "string" && e.response.content.content.toLowerCase().includes(searchLower);
-			const toolMatch = e.response?.toolCalls?.some((t) => t.name.toLowerCase().includes(searchLower));
-			const sysMatch = e.request.system?.toLowerCase().includes(searchLower);
-			return msgMatch || respMatch || toolMatch || sysMatch;
-		});
-	}
-	filtered.sort((a, b) => b.timestamp - a.timestamp);
-	const total = filtered.length;
-	const totalPages = Math.ceil(total / limit);
-	const start = (page - 1) * limit;
-	return {
-		entries: filtered.slice(start, start + limit),
-		total,
-		page,
-		limit,
-		totalPages
-	};
-}
-function getEntry(id) {
-	return entryIndex.get(id);
-}
-function getSessions() {
-	const sessions = Array.from(historyState.sessions.values()).sort((a, b) => b.lastActivity - a.lastActivity);
-	return {
-		sessions,
-		total: sessions.length
-	};
-}
-function getSession(id) {
-	return historyState.sessions.get(id);
-}
-function getSessionEntries(sessionId) {
-	return historyState.entries.filter((e) => e.sessionId === sessionId).sort((a, b) => a.timestamp - b.timestamp);
-}
-function clearHistory() {
-	historyState.entries = [];
-	historyState.sessions = /* @__PURE__ */ new Map();
-	historyState.currentSessionId = generateId$1();
-	entryIndex.clear();
-	notifyHistoryCleared();
-}
-function deleteSession(sessionId) {
-	if (!historyState.sessions.has(sessionId)) return false;
-	const removedEntries = historyState.entries.filter((e) => e.sessionId === sessionId);
-	historyState.entries = historyState.entries.filter((e) => e.sessionId !== sessionId);
-	for (const e of removedEntries) entryIndex.delete(e.id);
-	historyState.sessions.delete(sessionId);
-	if (historyState.currentSessionId === sessionId) historyState.currentSessionId = generateId$1();
-	notifySessionDeleted(sessionId);
-	return true;
+function deleteSession(sessionId) {
+	if (!historyState.sessions.has(sessionId)) return false;
+	const removedEntries = historyState.entries.filter((e) => e.sessionId === sessionId);
+	historyState.entries = historyState.entries.filter((e) => e.sessionId !== sessionId);
+	for (const e of removedEntries) entryIndex.delete(e.id);
+	historyState.sessions.delete(sessionId);
+	if (historyState.currentSessionId === sessionId) historyState.currentSessionId = generateId$1();
+	notifySessionDeleted(sessionId);
+	return true;
 }
 function getStats() {
 	const entries = historyState.entries;
@@ -2516,6 +1716,7 @@ async function gracefulShutdown(signal, deps) {
 		deps?.contextManager?.stopReaper();
 	} catch {}
 	stopMemoryPressureMonitor();
+	stopEventLoopLagMonitor();
 	stopRefresh();
 	const wsClients = getWsCount();
 	if (wsClients > 0) {
@@ -2594,6 +1795,944 @@ function setupShutdownHandlers() {
 	process.on("SIGTERM", () => handler("SIGTERM"));
 }
 
+//#endregion
+//#region src/lib/adaptive-rate-limiter.ts
+const DEFAULT_CONFIG$1 = {
+	baseRetryIntervalSeconds: 1,
+	maxRetryIntervalSeconds: 60,
+	maxRetries: 8
+};
+/**
+* Per-request adaptive rate limiter. Retries the calling request on 429 with
+* exponential backoff without blocking any other in-flight request.
+*/
+var AdaptiveRateLimiter = class {
+	config;
+	constructor(config = {}) {
+		this.config = {
+			...DEFAULT_CONFIG$1,
+			...config
+		};
+	}
+	/**
+	* Execute a request, retrying ONLY this request on 429 with exponential
+	* backoff. Never blocks other concurrent requests.
+	*/
+	async execute(fn) {
+		let attempt = 0;
+		let backoffMs = 0;
+		for (;;) try {
+			const result = await fn();
+			if (attempt > 0) addTiming(TIMING.LIMITER_RETRIES, attempt);
+			return {
+				result,
+				queueWaitMs: backoffMs
+			};
+		} catch (error) {
+			const { isRateLimit, retryAfter } = this.isRateLimitError(error);
+			if (!isRateLimit || attempt >= this.config.maxRetries || getIsShuttingDown()) throw error;
+			attempt++;
+			const delayMs = retryAfter !== void 0 && retryAfter > 0 ? retryAfter * 1e3 : this.withJitter(this.backoffSeconds(attempt) * 1e3);
+			backoffMs += delayMs;
+			await this.sleep(delayMs);
+		}
+	}
+	/**
+	* Check if an error is a rate limit error (429) and extract Retry-After if available.
+	*/
+	isRateLimitError(error) {
+		if (error && typeof error === "object") {
+			if ("status" in error && error.status === 429) return {
+				isRateLimit: true,
+				retryAfter: this.extractRetryAfter(error)
+			};
+			if ("responseText" in error && typeof error.responseText === "string") try {
+				const parsed = JSON.parse(error.responseText);
+				if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error && typeof parsed.error === "object" && "code" in parsed.error && parsed.error.code === "rate_limited") return { isRateLimit: true };
+			} catch {}
+		}
+		return { isRateLimit: false };
+	}
+	/**
+	* Extract Retry-After value from error response.
+	*/
+	extractRetryAfter(error) {
+		if (!error || typeof error !== "object") return void 0;
+		if ("responseText" in error && typeof error.responseText === "string") try {
+			const parsed = JSON.parse(error.responseText);
+			if (parsed && typeof parsed === "object" && "retry_after" in parsed && typeof parsed.retry_after === "number") return parsed.retry_after;
+			if (parsed && typeof parsed === "object" && "error" in parsed && parsed.error && typeof parsed.error === "object" && "retry_after" in parsed.error && typeof parsed.error.retry_after === "number") return parsed.error.retry_after;
+		} catch {}
+	}
+	/** Exponential backoff (seconds) for the given retry attempt, capped. */
+	backoffSeconds(attempt) {
+		const backoff = this.config.baseRetryIntervalSeconds * 2 ** (attempt - 1);
+		return Math.min(backoff, this.config.maxRetryIntervalSeconds);
+	}
+	/** Apply ±20% jitter so simultaneous retries don't hammer upstream in lockstep. */
+	withJitter(ms) {
+		const factor = .8 + Math.random() * .4;
+		return Math.round(ms * factor);
+	}
+	sleep(ms) {
+		return new Promise((resolve) => {
+			const timer = setTimeout(resolve, ms);
+			if (typeof timer.unref === "function") timer.unref();
+		});
+	}
+	/**
+	* No global queue in per-request mode, so there is nothing to reject. Retained
+	* for the shutdown call site (returns 0 = nothing drained).
+	*/
+	rejectQueued() {
+		return 0;
+	}
+};
+let rateLimiterInstance = null;
+/**
+* Initialize the adaptive rate limiter with configuration.
+*/
+function initAdaptiveRateLimiter(config = {}) {
+	rateLimiterInstance = new AdaptiveRateLimiter(config);
+	const resolved = {
+		...DEFAULT_CONFIG$1,
+		...config
+	};
+	consola.info(`[RateLimiter] Initialized (per-request backoff: ${resolved.baseRetryIntervalSeconds}s-${resolved.maxRetryIntervalSeconds}s, max ${resolved.maxRetries} retries)`);
+}
+/**
+* Get the rate limiter instance.
+*/
+function getAdaptiveRateLimiter() {
+	return rateLimiterInstance;
+}
+/**
+* Execute a request with adaptive rate limiting. If the limiter is not
+* initialized, executes immediately. Returns the result along with backoff wait.
+*/
+async function executeWithAdaptiveRateLimit(fn) {
+	if (!rateLimiterInstance) return {
+		result: await fn(),
+		queueWaitMs: 0
+	};
+	return rateLimiterInstance.execute(fn);
+}
+
+//#endregion
+//#region src/lib/auth-gate.ts
+/**
+* Auth gate — the inbound authentication decision point for the proxy.
+*
+* Protects this proxy's *inbound* surface with a configured **Proxy API key**
+* (NOT the outbound GitHub OAuth token or Copilot token). The decision logic
+* is expressed as pure functions so it can be unit-tested without booting the
+* server or reaching upstream.
+*/
+/**
+* Extract candidate presented credential values from request headers.
+*
+* Two header shapes are read, and **both** contribute candidates when present
+* (compare-all-present) so neither is silently ignored in favor of the other —
+* a later any-match over the candidates decides acceptance:
+*  - `Authorization`: the scheme prefix is stripped case-insensitively
+*    (`Bearer ` / `bearer ` …) because the scheme is case-insensitive per
+*    RFC 7235, while the secret itself is case-sensitive. A bare value with no
+*    scheme prefix is tolerated and returned verbatim.
+*  - `x-api-key` (Issue 02): the Anthropic-native header. Taken verbatim — no
+*    scheme stripping (a value that happens to start with `Bearer ` is kept
+*    as-is).
+*
+* Order is `[Authorization, x-api-key]` for any present header; absent headers
+* contribute nothing.
+*/
+function extractCredentials(headers) {
+	const candidates = [];
+	const authorization = headers.get("authorization");
+	if (authorization !== null) candidates.push(authorization.replace(/^Bearer\s+/i, ""));
+	const apiKey = headers.get("x-api-key");
+	if (apiKey !== null) candidates.push(apiKey);
+	return candidates;
+}
+/**
+* Hard-coded exemption set: the liveness (`/`) and readiness (`/health`)
+* endpoints are reachable without a key so container orchestration probes are
+* never blocked. Everything else is protected (fail-closed) — unknown / future
+* routes default to protected.
+*
+* Matching is by **exact path**, with a trailing slash tolerated (so `/health/`
+* is exempt too) and `/` itself handled explicitly. Prefix matching is
+* deliberately avoided: `/healthz` or `/health/extra` must NOT be exempt. The
+* server registers a matching `/health/` route, so an exempt `/health/` request
+* resolves to the readiness handler rather than 404ing.
+*/
+function isExemptPath(path) {
+	if (path === "/") return true;
+	return (path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path) === "/health";
+}
+/**
+* Compute the fixed-length sha256 digest (32 bytes) of the configured key.
+* The configured key is trimmed before hashing (config-side trim).
+*/
+function digestConfiguredKey(configuredKey) {
+	return createHash("sha256").update(configuredKey.trim()).digest();
+}
+/**
+* Constant-time membership test: does any presented candidate match the
+* configured key?
+*
+* Each candidate is sha256'd to a fixed 32-byte digest and compared against the
+* configured digest. Hashing to a fixed length sidesteps the `RangeError` that
+* `crypto.timingSafeEqual` throws on length-mismatched buffers, so a
+* wrong-length presented value yields `false` rather than throwing.
+*/
+function matchesConfiguredKey(configuredDigest, candidates) {
+	return candidates.some((candidate) => {
+		return timingSafeEqual(createHash("sha256").update(candidate).digest(), configuredDigest);
+	});
+}
+/**
+* Resolve the inbound Proxy API key from its two operator-facing sources,
+* applying the precedence + normalization contract (Issue 03):
+*
+*  - `--api-key` flag (`flag`) and `COPILOT_API_KEY` env (`env`) are each
+*    **trimmed first**; a trimmed-empty source (`""`, whitespace, or
+*    `undefined`) counts as **not provided**.
+*  - When both provide a non-empty value, the **flag wins** (env ignored).
+*  - When only one provides a non-empty value, that one is used.
+*  - When neither does, `key` is `undefined` and `source` is `"none"` → auth
+*    stays disabled (same as the no-`--api-key` default).
+*
+* Pure: it reads nothing from `process.env` itself (the caller passes the env
+* value in), so it is fully unit-testable and the precedence logic is decoupled
+* from how the values are sourced.
+*/
+function resolveProxyApiKey(sources) {
+	const flag = sources.flag?.trim() ?? "";
+	if (flag !== "") return {
+		key: flag,
+		source: "flag"
+	};
+	const env = sources.env?.trim() ?? "";
+	if (env !== "") return {
+		key: env,
+		source: "env"
+	};
+	return {
+		key: void 0,
+		source: "none"
+	};
+}
+/**
+* Resolve the hostname the server will *actually* bind to, decided at the CLI
+* edge with flag-over-env precedence and a **safe loopback default** — the same
+* flag-over-env shape this codebase already uses to reconcile a CLI flag with
+* its env twin (`--api-key`/`COPILOT_API_KEY`, `--github-token`/`GH_TOKEN`).
+*
+*  - `--host` flag wins when present; otherwise the `HOST` env; otherwise the
+*    default `127.0.0.1`.
+*  - The default is **loopback, not all-interfaces**: an unconfigured instance
+*    must not expose `/token` (which echoes the plaintext Copilot token) and the
+*    otherwise-unauthenticated API to the whole network. Binding every interface
+*    is now an explicit opt-in — pass `--host 0.0.0.0` (or `HOST=0.0.0.0`).
+*  - **flag vs env asymmetry on a blank value** (the security-critical part): an
+*    explicit `--host` flag is the operator's deliberate choice, so a blank flag
+*    (`--host ""` / whitespace) is taken as the wildcard-bind escape hatch and
+*    canonicalized to an explicit `0.0.0.0` (rather than left as `""` to lean on
+*    srvx's undocumented empty-string handling). But a *set-but-blank* `HOST` env
+*    (`HOST=`, or `HOST=$UNSET` in a shell / compose where the var is unset →
+*    empty — NOT a deliberate keystroke) is accidental plumbing, so it is treated
+*    as **not provided** and falls through to the loopback default. This mirrors
+*    `resolveProxyApiKey` trimming `""` to not-provided, so an empty `HOST` can't
+*    silently reopen the all-interfaces-unauthenticated exposure the loopback
+*    default exists to prevent.
+*  - **Both sources are trimmed**: a padded `--host " 10.0.0.5 "` or
+*    `HOST=" 10.0.0.5 "` would otherwise reach the socket bind verbatim and fail
+*    with `ENOTFOUND`. Trimming also decides blank-ness for the rules above.
+*
+* `env` is passed in (not read here) to keep the function pure and unit-testable.
+*/
+function resolveBindHost(flag, env) {
+	if (flag !== void 0) {
+		const trimmed = flag.trim();
+		return trimmed === "" ? "0.0.0.0" : trimmed;
+	}
+	const envTrimmed = env?.trim() ?? "";
+	if (envTrimmed !== "") return envTrimmed;
+	return "127.0.0.1";
+}
+/**
+* Resolve the address the server will *actually* bind to for the startup banner
+* (Issue 04).
+*
+* Mirrors srvx's own host resolution EXACTLY so the banner reports the TRUE bind
+* rather than a guess that could diverge from what srvx passes to the runtime.
+* srvx computes `hostname = opts.hostname ?? process.env.HOST` (a raw nullish
+* coalesce — no trimming, no empty-string special-casing), and start.ts passes
+* `hostname: options.host`. So:
+*   - an explicit `--host` (even `""` / whitespace) is what srvx uses verbatim —
+*     it does NOT fall back to HOST once `opts.hostname` is a non-null string;
+*   - only an absent (`undefined`) `--host` lets srvx fall back to `HOST`;
+*   - when the coalesced value is `undefined` or empty, the runtime binds all
+*     interfaces, which we report as the explicit `0.0.0.0` so a wide-open bind
+*     is unmistakable (srvx renders the same bind as "localhost (all
+*     interfaces)").
+*
+* Critically, the resolved non-empty value is returned VERBATIM (not trimmed):
+* srvx hands the runtime exactly that string, so the banner must report exactly
+* that string — trimming here would make the banner claim a different address
+* than the one actually bound. `env` is passed in (not read) to keep the
+* function pure and unit-testable.
+*/
+function resolveBindAddress(host, env) {
+	const resolved = host ?? env;
+	if (resolved === void 0 || resolved === "") return "0.0.0.0";
+	return resolved;
+}
+/**
+* Resolve the CLIENT-FACING host for generated configs and viewer links
+* (Issue 04), derived from the SAME srvx host resolution as the banner so the
+* two never disagree about what was bound — and formatted as a valid URL
+* authority so the links actually parse.
+*
+* Two differences from {@link resolveBindAddress}:
+*  - All-interfaces rendering: a wildcard bind (`0.0.0.0` / `::` / `[::]` /
+*    empty) is not a connectable target, so it maps to `localhost` for URLs a
+*    client will actually dial (matching srvx's "localhost (all interfaces)"
+*    presentation). A narrowed bind (e.g. `127.0.0.1`, `192.168.1.10`, an IPv6
+*    address) is kept so generated links point at the real interface — fixing
+*    the prior bug where setting `HOST` (with `--host` omitted) yielded
+*    `http://localhost:<port>` links the narrowed bind wasn't listening on.
+*  - IPv6 bracketing: a literal IPv6 host (contains `:`) is wrapped in `[...]`,
+*    exactly as srvx's own `fmtURL` does, so `http://[2001:db8::1]:<port>` is a
+*    valid authority rather than the unparseable `http://2001:db8::1:<port>`.
+*
+* Returns a host token ready to drop into `http://<token>:<port>`.
+*/
+function resolveClientHost(host, env) {
+	const bind = resolveBindAddress(host, env);
+	if (bind === "0.0.0.0" || bind === "::" || bind === "[::]") return "localhost";
+	if (bind.includes(":") && !bind.startsWith("[")) return `[${bind}]`;
+	return bind;
+}
+/**
+* Build the inbound-auth startup banner lines (Issue 04).
+*
+* Returns the human-readable lines the proxy prints at boot so operators can see,
+* at a glance, the security posture of *this* instance:
+*  - auth ON  → `认证开启`, plus the key's origin (`flag` / `env`), plus the real
+*    bind address.
+*  - auth OFF → `认证关闭`, plus the real bind address (so a careless all-
+*    interfaces bind without auth is visible).
+*
+* The configured key value is **never** an input here, so it can never leak into
+* the banner — the function only knows the *source* tag, not the secret. Pure
+* (string in → strings out) so the banner copy is pinned by unit tests.
+*/
+function buildStartupAuthLines(params) {
+	const { source, bindAddress } = params;
+	return [source === "none" ? `Inbound auth: 认证关闭 (no proxy API key configured)` : `Inbound auth: 认证开启 (source: ${source})`, `Binding to: ${bindAddress}`];
+}
+/**
+* Configure the proxy API key on global state from a raw configured value.
+*
+* The value is trimmed; a trimmed-empty value (or `undefined`) is treated as
+* "not provided" → auth stays disabled. Otherwise the precomputed digest is
+* stored on state (presence === enabled). Returns whether auth is enabled.
+*
+* The `--api-key` flag and `COPILOT_API_KEY` env source are reconciled upstream
+* by `resolveProxyApiKey` (flag-over-env precedence, Issue 03); this function
+* receives only the already-resolved value.
+*/
+function configureProxyApiKey(rawKey) {
+	const trimmed = rawKey?.trim() ?? "";
+	if (trimmed === "") {
+		state.proxyApiKeyDigest = void 0;
+		return false;
+	}
+	state.proxyApiKeyDigest = digestConfiguredKey(trimmed);
+	return true;
+}
+/**
+* Path → auth-family selector (Issue 02).
+*
+* The Anthropic-native surface is `/v1/messages` and its `count_tokens`
+* subpath; both map to the Anthropic family so a native Anthropic client gets
+* the `authentication_error` body. Everything else — including every other
+* `/v1/…` endpoint and any unknown / future route — defaults to the OpenAI
+* family.
+*
+* Matching is by **exact path** (a trailing slash tolerated), deliberately not
+* a prefix test: the shared `/v1/` prefix must not sweep OpenAI-style endpoints
+* into the Anthropic family, and `/v1/messages-extra` or a deeper unexpected
+* subpath must not be misclassified either. This mirrors `isExemptPath`'s
+* exact-with-trailing-slash convention.
+*/
+function selectFamily(path) {
+	const normalized = path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+	if (normalized === "/v1/messages" || normalized === "/v1/messages/count_tokens") return "anthropic";
+	return "openai";
+}
+/**
+* OpenAI-family 401 response body. The literal field values are pinned by the
+* ADR so OpenAI-compatible SDKs recognize the failure as an auth error. The
+* same body is returned whether credentials were missing or wrong (no oracle).
+*/
+function unauthorizedOpenAIBody() {
+	return { error: {
+		message: "Invalid API key provided.",
+		type: "invalid_request_error",
+		code: "invalid_api_key",
+		param: null
+	} };
+}
+/**
+* Anthropic-family 401 response body (Issue 02). Shape is pinned so Anthropic
+* SDKs (and Claude Code via `/v1/messages`) recognize the failure as an auth
+* error: a top-level `{type:"error", error:{type:"authentication_error",
+* message}}`. As with the OpenAI body, missing and wrong credentials return the
+* identical body (no oracle).
+*/
+function unauthorizedAnthropicBody() {
+	return {
+		type: "error",
+		error: {
+			type: "authentication_error",
+			message: "Invalid API key provided."
+		}
+	};
+}
+/**
+* Global fail-closed authentication middleware.
+*
+* Registered after the request logger and CORS but before route dispatch.
+* Behavior:
+*  - Disabled (no configured digest) → pass through unchanged (default).
+*  - Exempt path (`/`, `/health`) → pass through.
+*  - CORS preflight `OPTIONS` on a protected path → pass through so browser
+*    preflight isn't mistaken for a 401 (blocking it surfaces as an opaque CORS
+*    error, very hard to diagnose). Scoped to *actual* preflights — an
+*    `OPTIONS` carrying `Access-Control-Request-Method` — rather than any
+*    `OPTIONS`, so the bypass surface can't silently widen. Preflights carry no
+*    protected payload, so this doesn't weaken fail-closed.
+*  - Otherwise require a valid Proxy API key; on failure return 401 with a
+*    `WWW-Authenticate: Bearer` header and a **family-appropriate** body —
+*    Anthropic-family (`/v1/messages*`) gets the `authentication_error` shape,
+*    everything else the OpenAI `invalid_api_key` shape (Issue 02). The family
+*    only selects the body shape; it does not change what is protected. Missing
+*    and wrong credentials return the field-identical body for that family.
+*/
+function authGate() {
+	return async (c, next) => {
+		const configuredDigest = state.proxyApiKeyDigest;
+		if (!configuredDigest) return next();
+		if (isExemptPath(c.req.path)) return next();
+		if (c.req.method === "OPTIONS" && c.req.raw.headers.get("access-control-request-method") !== null) return next();
+		if (matchesConfiguredKey(configuredDigest, extractCredentials(c.req.raw.headers))) return next();
+		c.header("WWW-Authenticate", "Bearer");
+		if (selectFamily(c.req.path) === "anthropic") return c.json(unauthorizedAnthropicBody(), 401);
+		return c.json(unauthorizedOpenAIBody(), 401);
+	};
+}
+
+//#endregion
+//#region src/lib/context/request.ts
+let idCounter = 0;
+function createRequestContext(opts) {
+	const id = `req_${Date.now()}_${++idCounter}`;
+	const startTime = Date.now();
+	const onEvent = opts.onEvent;
+	let _state = "pending";
+	let _originalRequest = null;
+	let _response = null;
+	let settled = false;
+	function emit(event) {
+		try {
+			onEvent(event);
+		} catch {}
+	}
+	const ctx = {
+		id,
+		tuiLogId: opts.tuiLogId,
+		startTime,
+		endpoint: opts.endpoint,
+		get state() {
+			return _state;
+		},
+		get durationMs() {
+			return Date.now() - startTime;
+		},
+		get settled() {
+			return settled;
+		},
+		get originalRequest() {
+			return _originalRequest;
+		},
+		get response() {
+			return _response;
+		},
+		setOriginalRequest(req) {
+			_originalRequest = req;
+			emit({
+				type: "updated",
+				context: ctx,
+				field: "originalRequest"
+			});
+		},
+		transition(newState) {
+			const previousState = _state;
+			_state = newState;
+			emit({
+				type: "state_changed",
+				context: ctx,
+				previousState
+			});
+		},
+		complete(response) {
+			if (settled) return;
+			settled = true;
+			_response = response;
+			_state = "completed";
+			emit({
+				type: "completed",
+				context: ctx,
+				entry: ctx.toHistoryEntry()
+			});
+		},
+		fail(model, error) {
+			if (settled) return;
+			settled = true;
+			_response = {
+				success: false,
+				model,
+				usage: {
+					input_tokens: 0,
+					output_tokens: 0
+				},
+				error: error instanceof Error ? error.message : String(error),
+				content: null
+			};
+			_state = "failed";
+			emit({
+				type: "failed",
+				context: ctx,
+				entry: ctx.toHistoryEntry()
+			});
+		},
+		toHistoryEntry() {
+			const entry = {
+				id,
+				endpoint: opts.endpoint,
+				timestamp: startTime,
+				durationMs: Date.now() - startTime,
+				request: {
+					model: _originalRequest?.model,
+					messages: _originalRequest?.messages,
+					stream: _originalRequest?.stream,
+					tools: _originalRequest?.tools,
+					system: _originalRequest?.system
+				}
+			};
+			if (_response) entry.response = _response;
+			return entry;
+		}
+	};
+	return ctx;
+}
+
+//#endregion
+//#region src/lib/context/manager.ts
+/**
+* RequestContextManager — Active request management
+*
+* Manages all in-flight RequestContext instances. Publishes events for
+* WebSocket push and history persistence.
+*/
+let _manager = null;
+function initRequestContextManager(staleMaxAgeSec) {
+	_manager = createRequestContextManager(staleMaxAgeSec);
+	return _manager;
+}
+const REAPER_INTERVAL_MS = 6e4;
+const DEFAULT_STALE_MAX_AGE_SEC = 600;
+function createRequestContextManager(staleMaxAgeSec) {
+	const maxAgeSec = staleMaxAgeSec ?? DEFAULT_STALE_MAX_AGE_SEC;
+	const activeContexts = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let reaperTimer = null;
+	function runReaperOnce() {
+		if (maxAgeSec <= 0) return;
+		const maxAgeMs = maxAgeSec * 1e3;
+		for (const [id, ctx] of activeContexts) if (ctx.durationMs > maxAgeMs) {
+			consola.warn(`[context] Force-failing stale request ${id} (endpoint: ${ctx.endpoint}, model: ${ctx.originalRequest?.model ?? "unknown"}, state: ${ctx.state}, age: ${Math.round(ctx.durationMs / 1e3)}s, max: ${maxAgeSec}s)`);
+			ctx.fail(ctx.originalRequest?.model ?? "unknown", /* @__PURE__ */ new Error(`Request exceeded maximum age of ${maxAgeSec}s (stale context reaper)`));
+		}
+	}
+	function startReaper() {
+		if (reaperTimer) return;
+		reaperTimer = setInterval(runReaperOnce, REAPER_INTERVAL_MS);
+	}
+	function stopReaper() {
+		if (reaperTimer) {
+			clearInterval(reaperTimer);
+			reaperTimer = null;
+		}
+	}
+	function emit(event) {
+		for (const listener of listeners) try {
+			listener(event);
+		} catch {}
+	}
+	function handleContextEvent(rawEvent) {
+		const { type, context } = rawEvent;
+		switch (type) {
+			case "state_changed":
+				if (rawEvent.previousState) emit({
+					type: "state_changed",
+					context,
+					previousState: rawEvent.previousState
+				});
+				break;
+			case "updated":
+				if (rawEvent.field) emit({
+					type: "updated",
+					context,
+					field: rawEvent.field
+				});
+				break;
+			case "completed":
+				if (rawEvent.entry) emit({
+					type: "completed",
+					context,
+					entry: rawEvent.entry
+				});
+				activeContexts.delete(context.id);
+				break;
+			case "failed":
+				if (rawEvent.entry) emit({
+					type: "failed",
+					context,
+					entry: rawEvent.entry
+				});
+				activeContexts.delete(context.id);
+				break;
+			default: break;
+		}
+	}
+	return {
+		create(opts) {
+			const ctx = createRequestContext({
+				endpoint: opts.endpoint,
+				tuiLogId: opts.tuiLogId,
+				onEvent: handleContextEvent
+			});
+			activeContexts.set(ctx.id, ctx);
+			emit({
+				type: "created",
+				context: ctx
+			});
+			return ctx;
+		},
+		get(id) {
+			return activeContexts.get(id);
+		},
+		getAll() {
+			return Array.from(activeContexts.values());
+		},
+		get activeCount() {
+			return activeContexts.size;
+		},
+		on(_event, listener) {
+			listeners.add(listener);
+		},
+		off(_event, listener) {
+			listeners.delete(listener);
+		},
+		startReaper,
+		stopReaper,
+		_runReaperOnce: runReaperOnce
+	};
+}
+
+//#endregion
+//#region src/lib/hidden-models.ts
+/**
+* Hardcoded list of GitHub Copilot model ids that are hidden from listing
+* endpoints (the /v1/models response, the startup ASCII banner, and the
+* --claude-code interactive prompts), unless `--show-all-models` is passed.
+*
+* Note: this is a DISPLAY filter only. Explicit POSTs to handler endpoints
+* with a hidden id are NOT rejected — they pass through to upstream verbatim.
+*
+* Bumping the list requires a code change + release. No env var, no config
+* file, no CLI append interface.
+*/
+const HIDDEN_MODEL_IDS = new Set([
+	"gpt-3.5-turbo",
+	"gpt-3.5-turbo-0613",
+	"gpt-4",
+	"gpt-4-0613",
+	"gpt-4-0125-preview",
+	"gpt-4o",
+	"gpt-4o-mini",
+	"gpt-4-o-preview",
+	"gpt-4o-2024-05-13",
+	"gpt-4o-2024-08-06",
+	"gpt-4o-2024-11-20",
+	"gpt-4o-mini-2024-07-18",
+	"gpt-4.1",
+	"gpt-4.1-2025-04-14",
+	"gpt-41-copilot",
+	"gpt-5-mini",
+	"gpt-5.3-codex",
+	"text-embedding-ada-002",
+	"text-embedding-3-small",
+	"text-embedding-3-small-inference",
+	"gemini-2.5-pro",
+	"gemini-3-flash-preview",
+	"claude-opus-4.5",
+	"claude-opus-4.6",
+	"claude-opus-4.7-high",
+	"claude-opus-4.7-xhigh",
+	"claude-sonnet-4.5",
+	"mai-code-1-flash-internal",
+	"trajectory-compaction"
+]);
+function isHiddenModel(id, showAll) {
+	if (showAll) return false;
+	return HIDDEN_MODEL_IDS.has(id);
+}
+
+//#endregion
+//#region src/lib/tokenizer.ts
+const ENCODING_MAP = {
+	o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
+	cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
+	p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
+	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
+	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
+};
+const encodingCache = /* @__PURE__ */ new Map();
+const encodingInflight = /* @__PURE__ */ new Map();
+/**
+* Calculate tokens for tool calls
+*/
+const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
+	let tokens = 0;
+	for (const toolCall of toolCalls) {
+		tokens += constants.funcInit;
+		tokens += encoder.encode(JSON.stringify(toolCall)).length;
+	}
+	tokens += constants.funcEnd;
+	return tokens;
+};
+/**
+* Calculate tokens for content parts
+*/
+const calculateContentPartsTokens = (contentParts, encoder) => {
+	let tokens = 0;
+	for (const part of contentParts) if (part.type === "image_url") tokens += encoder.encode(part.image_url.url).length + 85;
+	else if (part.text) tokens += encoder.encode(part.text).length;
+	return tokens;
+};
+/**
+* Calculate tokens for a single message
+*/
+const calculateMessageTokens = (message, encoder, constants) => {
+	const tokensPerMessage = 3;
+	const tokensPerName = 1;
+	let tokens = tokensPerMessage;
+	for (const [key, value] of Object.entries(message)) {
+		if (typeof value === "string") tokens += encoder.encode(value).length;
+		if (key === "name") tokens += tokensPerName;
+		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder, constants);
+		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder);
+	}
+	return tokens;
+};
+/**
+* Calculate tokens using custom algorithm
+*/
+const calculateTokens = (messages, encoder, constants) => {
+	if (messages.length === 0) return 0;
+	let numTokens = 0;
+	for (const message of messages) numTokens += calculateMessageTokens(message, encoder, constants);
+	numTokens += 3;
+	return numTokens;
+};
+/**
+* Get the corresponding encoder module based on encoding type. Resolved
+* encoders are cached; concurrent first-loads are de-duplicated via the
+* in-flight map; and the cold BPE-table import is timed under TOKENIZE_COLD so
+* a first-request stall is distinguishable from steady-state encode cost.
+*/
+const getEncodeChatFunction = async (encoding) => {
+	const cached = encodingCache.get(encoding);
+	if (cached) return cached;
+	const inflight = encodingInflight.get(encoding);
+	if (inflight) return inflight;
+	const loader = encoding in ENCODING_MAP ? ENCODING_MAP[encoding] : ENCODING_MAP.o200k_base;
+	const loadPromise = (async () => {
+		const start = performance.now();
+		const mod = await loader();
+		addTiming(TIMING.TOKENIZE_COLD, performance.now() - start);
+		encodingCache.set(encoding, mod);
+		return mod;
+	})();
+	encodingInflight.set(encoding, loadPromise);
+	try {
+		return await loadPromise;
+	} finally {
+		encodingInflight.delete(encoding);
+	}
+};
+/**
+* Pre-load the default encoder at startup so the first burst of concurrent
+* requests doesn't pay the cold BPE-table import on the shared event loop.
+*/
+async function warmupTokenizer() {
+	await getEncodeChatFunction("o200k_base");
+}
+/**
+* Get tokenizer type from model information
+*/
+const getTokenizerFromModel = (model) => {
+	return model.capabilities?.tokenizer || "o200k_base";
+};
+/**
+* Count tokens in a text string using the model's tokenizer.
+* This is a simple wrapper for counting tokens in plain text.
+*/
+const countTextTokens = async (text, model) => {
+	const encoder = await getEncodeChatFunction(getTokenizerFromModel(model));
+	return timeSync(TIMING.TOKENIZE, () => encoder.encode(text).length);
+};
+/**
+* Get model-specific constants for token calculation.
+* These values are empirically determined based on OpenAI's function calling token overhead.
+* - funcInit: Tokens for initializing a function definition
+* - propInit: Tokens for initializing the properties section
+* - propKey: Tokens per property key
+* - enumInit: Token adjustment when enum is present (negative because type info is replaced)
+* - enumItem: Tokens per enum value
+* - funcEnd: Tokens for closing the function definition
+*/
+const getModelConstants = (model) => {
+	return model.id === "gpt-3.5-turbo" || model.id === "gpt-4" ? {
+		funcInit: 10,
+		propInit: 3,
+		propKey: 3,
+		enumInit: -3,
+		enumItem: 3,
+		funcEnd: 12
+	} : {
+		funcInit: 7,
+		propInit: 3,
+		propKey: 3,
+		enumInit: -3,
+		enumItem: 3,
+		funcEnd: 12
+	};
+};
+/**
+* Calculate tokens for a single parameter
+*/
+const calculateParameterTokens = (key, prop, context) => {
+	const { encoder, constants } = context;
+	let tokens = constants.propKey;
+	if (typeof prop !== "object" || prop === null) return tokens;
+	const param = prop;
+	const paramName = key;
+	const paramType = param.type || "string";
+	let paramDesc = param.description || "";
+	if (param.enum && Array.isArray(param.enum)) {
+		tokens += constants.enumInit;
+		for (const item of param.enum) {
+			tokens += constants.enumItem;
+			tokens += encoder.encode(String(item)).length;
+		}
+	}
+	if (paramDesc.endsWith(".")) paramDesc = paramDesc.slice(0, -1);
+	const line = `${paramName}:${paramType}:${paramDesc}`;
+	tokens += encoder.encode(line).length;
+	const excludedKeys = new Set([
+		"type",
+		"description",
+		"enum"
+	]);
+	for (const propertyName of Object.keys(param)) if (!excludedKeys.has(propertyName)) {
+		const propertyValue = param[propertyName];
+		const propertyText = typeof propertyValue === "string" ? propertyValue : JSON.stringify(propertyValue);
+		tokens += encoder.encode(`${propertyName}:${propertyText}`).length;
+	}
+	return tokens;
+};
+/**
+* Calculate tokens for function parameters
+*/
+const calculateParametersTokens = (parameters, encoder, constants) => {
+	if (!parameters || typeof parameters !== "object") return 0;
+	const params = parameters;
+	let tokens = 0;
+	for (const [key, value] of Object.entries(params)) if (key === "properties") {
+		const properties = value;
+		if (Object.keys(properties).length > 0) {
+			tokens += constants.propInit;
+			for (const propKey of Object.keys(properties)) tokens += calculateParameterTokens(propKey, properties[propKey], {
+				encoder,
+				constants
+			});
+		}
+	} else {
+		const paramText = typeof value === "string" ? value : JSON.stringify(value);
+		tokens += encoder.encode(`${key}:${paramText}`).length;
+	}
+	return tokens;
+};
+/**
+* Calculate tokens for a single tool
+*/
+const calculateToolTokens = (tool, encoder, constants) => {
+	let tokens = constants.funcInit;
+	const func = tool.function;
+	const fName = func.name;
+	let fDesc = func.description || "";
+	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
+	const line = fName + ":" + fDesc;
+	tokens += encoder.encode(line).length;
+	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder, constants);
+	return tokens;
+};
+/**
+* Calculate token count for tools based on model
+*/
+const numTokensForTools = (tools, encoder, constants) => {
+	let funcTokenCount = 0;
+	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
+	funcTokenCount += constants.funcEnd;
+	return funcTokenCount;
+};
+/**
+* Calculate the token count of messages.
+* Uses the tokenizer specified by the GitHub Copilot API model info.
+* All models (including Claude) use GPT tokenizers (o200k_base or cl100k_base).
+*/
+const getTokenCount = async (payload, model) => {
+	const encoder = await getEncodeChatFunction(getTokenizerFromModel(model));
+	return timeSync(TIMING.TOKENIZE, () => {
+		const simplifiedMessages = payload.messages;
+		const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
+		const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
+		const constants = getModelConstants(model);
+		let inputTokens = calculateTokens(inputMessages, encoder, constants);
+		if (payload.tools && payload.tools.length > 0) inputTokens += numTokensForTools(payload.tools, encoder, constants);
+		const outputTokens = calculateTokens(outputMessages, encoder, constants);
+		return {
+			input: inputTokens,
+			output: outputTokens
+		};
+	});
+};
+
 //#endregion
 //#region src/lib/tui/console-renderer.ts
 const CLEAR_LINE = "\x1B[2K\r";
@@ -2716,7 +2855,7 @@ var ConsoleRenderer = class {
 	* Format a complete log line with colored parts
 	*/
 	formatLogLine(parts) {
-		const { prefix, time, method, path, model, status, duration, tokens, queueWait, extra, isError, isDim } = parts;
+		const { prefix, time, method, path, model, status, duration, tokens, queueWait, phases, extra, isError, isDim } = parts;
 		if (isDim) {
 			const modelPart = model ? ` ${model}` : "";
 			const extraPart = extra ? ` ${extra}` : "";
@@ -2730,6 +2869,7 @@ var ConsoleRenderer = class {
 		if (duration) result += ` ${pc.yellow(duration)}`;
 		if (queueWait) result += ` ${pc.dim(`(queued ${queueWait})`)}`;
 		if (tokens) result += ` ${pc.blue(tokens)}`;
+		if (phases) result += ` ${pc.dim(phases)}`;
 		if (extra) result += isError ? pc.red(extra) : extra;
 		return result;
 	}
@@ -2750,6 +2890,19 @@ var ConsoleRenderer = class {
 		if (request.resolvedModel) return `${request.model} -> ${request.resolvedModel}`;
 		return request.model;
 	}
+	/**
+	* Compact per-phase timing breakdown for the complete line, e.g.
+	* "tok=86ms ttfb=120ms". Only non-zero phases are shown, so a request that
+	* skipped a phase stays terse.
+	*/
+	formatPhases(request) {
+		const parts = [];
+		if (request.tokenizeMs) parts.push(`tok=${formatDuration(Math.round(request.tokenizeMs))}`);
+		if (request.tokenizeColdMs) parts.push(`tok+=${formatDuration(Math.round(request.tokenizeColdMs))}`);
+		if (request.upstreamTtfbMs) parts.push(`ttfb=${formatDuration(Math.round(request.upstreamTtfbMs))}`);
+		if (request.limiterRetries) parts.push(`retries=${request.limiterRetries}`);
+		return parts.length > 0 ? parts.join(" ") : void 0;
+	}
 	onRequestStart(request) {
 		this.activeRequests.set(request.id, request);
 		if (this.showActive && consola.level >= 5) {
@@ -2798,6 +2951,7 @@ var ConsoleRenderer = class {
 			duration: formatDuration(request.durationMs ?? 0),
 			queueWait,
 			tokens,
+			phases: this.formatPhases(request),
 			extra: isError && request.error ? `: ${request.error}` : void 0,
 			isError,
 			isDim: request.isHistoryAccess
@@ -2817,7 +2971,7 @@ var ConsoleRenderer = class {
 //#endregion
 //#region src/lib/tui/tracker.ts
 function generateId() {
-	return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+	return randomUUID();
 }
 var RequestTracker = class {
 	requests = /* @__PURE__ */ new Map();
@@ -2848,6 +3002,7 @@ var RequestTracker = class {
 			status: "executing",
 			isHistoryAccess: options.isHistoryAccess
 		};
+		if (this.requests.has(id)) consola.warn(`[tracker] request id collision, overwriting in-flight: ${id}`);
 		this.requests.set(id, request);
 		this.renderer?.onRequestStart(request);
 		return id;
@@ -2867,6 +3022,10 @@ var RequestTracker = class {
 		if (update.error !== void 0) request.error = update.error;
 		if (update.queuePosition !== void 0) request.queuePosition = update.queuePosition;
 		if (update.queueWaitMs !== void 0) request.queueWaitMs = update.queueWaitMs;
+		for (const key of Object.values(TIMING)) {
+			const value = update[key];
+			if (value !== void 0) request[key] = value;
+		}
 		this.renderer?.onRequestUpdate(id, update);
 	}
 	/**
@@ -2959,35 +3118,39 @@ const requestTracker = new RequestTracker();
 function tuiLogger() {
 	return async (c, next) => {
 		if (getIsShuttingDown()) return c.json({ error: "Server is shutting down" }, 503);
-		const method = c.req.method;
-		const path = c.req.path;
-		const isHistoryAccess = path.startsWith("/history");
-		const trackingId = requestTracker.startRequest({
-			method,
-			path,
-			model: "",
-			isHistoryAccess
-		});
-		c.set("trackingId", trackingId);
-		try {
-			await next();
-			if ((c.res.headers.get("content-type") ?? "").includes("text/event-stream")) return;
-			const status = c.res.status;
-			const inputTokens = c.res.headers.get("x-input-tokens");
-			const outputTokens = c.res.headers.get("x-output-tokens");
-			const model = c.res.headers.get("x-model");
-			if (model) {
-				const request = requestTracker.getRequest(trackingId);
-				if (request) request.model = model;
+		return runWithTimings(async () => {
+			const method = c.req.method;
+			const path = c.req.path;
+			const isHistoryAccess = path.startsWith("/history");
+			const trackingId = requestTracker.startRequest({
+				method,
+				path,
+				model: "",
+				isHistoryAccess
+			});
+			c.set("trackingId", trackingId);
+			try {
+				await next();
+				if ((c.res.headers.get("content-type") ?? "").includes("text/event-stream")) return;
+				const status = c.res.status;
+				const inputTokens = c.res.headers.get("x-input-tokens");
+				const outputTokens = c.res.headers.get("x-output-tokens");
+				const model = c.res.headers.get("x-model");
+				if (model) {
+					const request = requestTracker.getRequest(trackingId);
+					if (request) request.model = model;
+				}
+				requestTracker.updateRequest(trackingId, timingsToUpdate(getTimings()));
+				requestTracker.completeRequest(trackingId, status, inputTokens && outputTokens ? {
+					inputTokens: Number.parseInt(inputTokens, 10),
+					outputTokens: Number.parseInt(outputTokens, 10)
+				} : void 0);
+			} catch (error) {
+				requestTracker.updateRequest(trackingId, timingsToUpdate(getTimings()));
+				requestTracker.failRequest(trackingId, error instanceof Error ? error.message : "Unknown error");
+				throw error;
 			}
-			requestTracker.completeRequest(trackingId, status, inputTokens && outputTokens ? {
-				inputTokens: Number.parseInt(inputTokens, 10),
-				outputTokens: Number.parseInt(outputTokens, 10)
-			} : void 0);
-		} catch (error) {
-			requestTracker.failRequest(trackingId, error instanceof Error ? error.message : "Unknown error");
-			throw error;
-		}
+		});
 	};
 }
 
@@ -3033,218 +3196,6 @@ function removeSystemReminderTags(text) {
 	return result;
 }
 
-//#endregion
-//#region src/lib/tokenizer.ts
-const ENCODING_MAP = {
-	o200k_base: () => import("gpt-tokenizer/encoding/o200k_base"),
-	cl100k_base: () => import("gpt-tokenizer/encoding/cl100k_base"),
-	p50k_base: () => import("gpt-tokenizer/encoding/p50k_base"),
-	p50k_edit: () => import("gpt-tokenizer/encoding/p50k_edit"),
-	r50k_base: () => import("gpt-tokenizer/encoding/r50k_base")
-};
-const encodingCache = /* @__PURE__ */ new Map();
-/**
-* Calculate tokens for tool calls
-*/
-const calculateToolCallsTokens = (toolCalls, encoder, constants) => {
-	let tokens = 0;
-	for (const toolCall of toolCalls) {
-		tokens += constants.funcInit;
-		tokens += encoder.encode(JSON.stringify(toolCall)).length;
-	}
-	tokens += constants.funcEnd;
-	return tokens;
-};
-/**
-* Calculate tokens for content parts
-*/
-const calculateContentPartsTokens = (contentParts, encoder) => {
-	let tokens = 0;
-	for (const part of contentParts) if (part.type === "image_url") tokens += encoder.encode(part.image_url.url).length + 85;
-	else if (part.text) tokens += encoder.encode(part.text).length;
-	return tokens;
-};
-/**
-* Calculate tokens for a single message
-*/
-const calculateMessageTokens = (message, encoder, constants) => {
-	const tokensPerMessage = 3;
-	const tokensPerName = 1;
-	let tokens = tokensPerMessage;
-	for (const [key, value] of Object.entries(message)) {
-		if (typeof value === "string") tokens += encoder.encode(value).length;
-		if (key === "name") tokens += tokensPerName;
-		if (key === "tool_calls") tokens += calculateToolCallsTokens(value, encoder, constants);
-		if (key === "content" && Array.isArray(value)) tokens += calculateContentPartsTokens(value, encoder);
-	}
-	return tokens;
-};
-/**
-* Calculate tokens using custom algorithm
-*/
-const calculateTokens = (messages, encoder, constants) => {
-	if (messages.length === 0) return 0;
-	let numTokens = 0;
-	for (const message of messages) numTokens += calculateMessageTokens(message, encoder, constants);
-	numTokens += 3;
-	return numTokens;
-};
-/**
-* Get the corresponding encoder module based on encoding type
-*/
-const getEncodeChatFunction = async (encoding) => {
-	if (encodingCache.has(encoding)) {
-		const cached = encodingCache.get(encoding);
-		if (cached) return cached;
-	}
-	const supportedEncoding = encoding;
-	if (!(supportedEncoding in ENCODING_MAP)) {
-		const fallbackModule = await ENCODING_MAP.o200k_base();
-		encodingCache.set(encoding, fallbackModule);
-		return fallbackModule;
-	}
-	const encodingModule = await ENCODING_MAP[supportedEncoding]();
-	encodingCache.set(encoding, encodingModule);
-	return encodingModule;
-};
-/**
-* Get tokenizer type from model information
-*/
-const getTokenizerFromModel = (model) => {
-	return model.capabilities?.tokenizer || "o200k_base";
-};
-/**
-* Count tokens in a text string using the model's tokenizer.
-* This is a simple wrapper for counting tokens in plain text.
-*/
-const countTextTokens = async (text, model) => {
-	return (await getEncodeChatFunction(getTokenizerFromModel(model))).encode(text).length;
-};
-/**
-* Get model-specific constants for token calculation.
-* These values are empirically determined based on OpenAI's function calling token overhead.
-* - funcInit: Tokens for initializing a function definition
-* - propInit: Tokens for initializing the properties section
-* - propKey: Tokens per property key
-* - enumInit: Token adjustment when enum is present (negative because type info is replaced)
-* - enumItem: Tokens per enum value
-* - funcEnd: Tokens for closing the function definition
-*/
-const getModelConstants = (model) => {
-	return model.id === "gpt-3.5-turbo" || model.id === "gpt-4" ? {
-		funcInit: 10,
-		propInit: 3,
-		propKey: 3,
-		enumInit: -3,
-		enumItem: 3,
-		funcEnd: 12
-	} : {
-		funcInit: 7,
-		propInit: 3,
-		propKey: 3,
-		enumInit: -3,
-		enumItem: 3,
-		funcEnd: 12
-	};
-};
-/**
-* Calculate tokens for a single parameter
-*/
-const calculateParameterTokens = (key, prop, context) => {
-	const { encoder, constants } = context;
-	let tokens = constants.propKey;
-	if (typeof prop !== "object" || prop === null) return tokens;
-	const param = prop;
-	const paramName = key;
-	const paramType = param.type || "string";
-	let paramDesc = param.description || "";
-	if (param.enum && Array.isArray(param.enum)) {
-		tokens += constants.enumInit;
-		for (const item of param.enum) {
-			tokens += constants.enumItem;
-			tokens += encoder.encode(String(item)).length;
-		}
-	}
-	if (paramDesc.endsWith(".")) paramDesc = paramDesc.slice(0, -1);
-	const line = `${paramName}:${paramType}:${paramDesc}`;
-	tokens += encoder.encode(line).length;
-	const excludedKeys = new Set([
-		"type",
-		"description",
-		"enum"
-	]);
-	for (const propertyName of Object.keys(param)) if (!excludedKeys.has(propertyName)) {
-		const propertyValue = param[propertyName];
-		const propertyText = typeof propertyValue === "string" ? propertyValue : JSON.stringify(propertyValue);
-		tokens += encoder.encode(`${propertyName}:${propertyText}`).length;
-	}
-	return tokens;
-};
-/**
-* Calculate tokens for function parameters
-*/
-const calculateParametersTokens = (parameters, encoder, constants) => {
-	if (!parameters || typeof parameters !== "object") return 0;
-	const params = parameters;
-	let tokens = 0;
-	for (const [key, value] of Object.entries(params)) if (key === "properties") {
-		const properties = value;
-		if (Object.keys(properties).length > 0) {
-			tokens += constants.propInit;
-			for (const propKey of Object.keys(properties)) tokens += calculateParameterTokens(propKey, properties[propKey], {
-				encoder,
-				constants
-			});
-		}
-	} else {
-		const paramText = typeof value === "string" ? value : JSON.stringify(value);
-		tokens += encoder.encode(`${key}:${paramText}`).length;
-	}
-	return tokens;
-};
-/**
-* Calculate tokens for a single tool
-*/
-const calculateToolTokens = (tool, encoder, constants) => {
-	let tokens = constants.funcInit;
-	const func = tool.function;
-	const fName = func.name;
-	let fDesc = func.description || "";
-	if (fDesc.endsWith(".")) fDesc = fDesc.slice(0, -1);
-	const line = fName + ":" + fDesc;
-	tokens += encoder.encode(line).length;
-	if (typeof func.parameters === "object" && func.parameters !== null) tokens += calculateParametersTokens(func.parameters, encoder, constants);
-	return tokens;
-};
-/**
-* Calculate token count for tools based on model
-*/
-const numTokensForTools = (tools, encoder, constants) => {
-	let funcTokenCount = 0;
-	for (const tool of tools) funcTokenCount += calculateToolTokens(tool, encoder, constants);
-	funcTokenCount += constants.funcEnd;
-	return funcTokenCount;
-};
-/**
-* Calculate the token count of messages.
-* Uses the tokenizer specified by the GitHub Copilot API model info.
-* All models (including Claude) use GPT tokenizers (o200k_base or cl100k_base).
-*/
-const getTokenCount = async (payload, model) => {
-	const encoder = await getEncodeChatFunction(getTokenizerFromModel(model));
-	const simplifiedMessages = payload.messages;
-	const inputMessages = simplifiedMessages.filter((msg) => msg.role !== "assistant");
-	const outputMessages = simplifiedMessages.filter((msg) => msg.role === "assistant");
-	const constants = getModelConstants(model);
-	let inputTokens = calculateTokens(inputMessages, encoder, constants);
-	if (payload.tools && payload.tools.length > 0) inputTokens += numTokensForTools(payload.tools, encoder, constants);
-	const outputTokens = calculateTokens(outputMessages, encoder, constants);
-	return {
-		input: inputTokens,
-		output: outputTokens
-	};
-};
-
 //#endregion
 //#region src/lib/auto-truncate-openai.ts
 /**
@@ -4198,13 +4149,14 @@ function updateTrackerStatus(trackingId, status) {
 	requestTracker.updateRequest(trackingId, { status });
 }
 /** Complete TUI tracking and send PostHog analytics */
-function completeTracking(trackingId, inputTokens, outputTokens, queueWaitMs, reasoningTokens, analytics) {
+function completeTracking(trackingId, inputTokens, outputTokens, queueWaitMs, reasoningTokens, analytics, timings) {
 	if (!trackingId) return;
 	requestTracker.updateRequest(trackingId, {
 		inputTokens,
 		outputTokens,
 		queueWaitMs,
-		reasoningTokens
+		reasoningTokens,
+		...timingsToUpdate(timings)
 	});
 	requestTracker.completeRequest(trackingId, 200, {
 		inputTokens,
@@ -4250,7 +4202,8 @@ function createEntryContext(args) {
 			historyId: recordRequest(args.endpoint, args.buildHistoryRequest(payload)),
 			trackingId,
 			startTime,
-			requestedModel
+			requestedModel,
+			timings: getTimings()
 		}
 	};
 }
@@ -4506,7 +4459,7 @@ async function handleStreamingResponse$1(opts) {
 			durationMs: Date.now() - ctx.startTime,
 			stopReason: acc.finishReason || void 0,
 			toolCount: payload.tools?.length ?? 0
-		});
+		}, ctx.timings);
 	} catch (error) {
 		recordStreamError({
 			acc,
@@ -6961,8 +6914,9 @@ const SSE_PING = ": ping\n\n";
 /**
 * Grace period before opening a keepalive stream. Normal upstream responses
 * resolve sub-second (response headers arrive immediately, the body is not
-* buffered); only a request queued behind the rate limiter takes >=10s. 3s
-* cleanly separates the two — a request still pending after 3s is queued.
+* buffered); only a request retrying behind the rate limiter's backoff stays
+* pending for seconds. 3s cleanly separates the two — a request still pending
+* after 3s is backing off.
 */
 const RATE_LIMIT_GRACE_MS = 3e3;
 /**
@@ -8449,7 +8403,7 @@ async function handleDirectAnthropicStreamingResponse(opts) {
 			durationMs: Date.now() - ctx.startTime,
 			stopReason: acc.stopReason || void 0,
 			toolCount: anthropicPayload.tools?.length ?? 0
-		});
+		}, ctx.timings);
 	} catch (error) {
 		consola.error("Direct Anthropic stream error:", formatError(error));
 		recordStreamError({
@@ -8694,7 +8648,7 @@ async function handleStreamingResponse(opts) {
 			durationMs: Date.now() - ctx.startTime,
 			stopReason: acc.stopReason || void 0,
 			toolCount: anthropicPayload.tools?.length ?? 0
-		});
+		}, ctx.timings);
 	} catch (error) {
 		consola.error("Stream error:", formatError(error));
 		recordStreamError({
@@ -9286,7 +9240,7 @@ const handleResponses = async (c) => {
 							stream: true,
 							durationMs: Date.now() - startTime,
 							toolCount: tools.length
-						});
+						}, ctx.timings);
 					} else if (streamErrorMessage) {
 						recordResponse(historyId, {
 							success: false,
@@ -9298,8 +9252,8 @@ const handleResponses = async (c) => {
 							error: streamErrorMessage,
 							content: null
 						}, Date.now() - startTime);
-						completeTracking(trackingId, 0, 0, queueWaitMs);
-					} else completeTracking(trackingId, 0, 0, queueWaitMs);
+						completeTracking(trackingId, 0, 0, queueWaitMs, void 0, void 0, ctx.timings);
+					} else completeTracking(trackingId, 0, 0, queueWaitMs, void 0, void 0, ctx.timings);
 				} catch (error) {
 					recordStreamError({
 						acc: { model: finalResult?.model || model },
@@ -9332,7 +9286,7 @@ const handleResponses = async (c) => {
 			stream: false,
 			durationMs: Date.now() - startTime,
 			toolCount: tools.length
-		});
+		}, ctx.timings);
 		consola.debug("Forwarding native Responses result:", JSON.stringify(result).slice(-400));
 		return c.json(echoResponseBody(result, ctx));
 	} catch (error) {
@@ -9505,6 +9459,7 @@ async function runServer(options) {
 	initHistory(true, 1e3);
 	consola.info("History recording enabled (max 1000 entries)");
 	startMemoryPressureMonitor();
+	startEventLoopLagMonitor();
 	if (options.posthogKey) {
 		initPostHog(options.posthogKey);
 		if (isPostHogEnabled()) consola.info("PostHog analytics enabled");
@@ -9525,6 +9480,7 @@ async function runServer(options) {
 		consola.error(error instanceof Error ? error.message : String(error));
 		process.exit(1);
 	}
+	await warmupTokenizer();
 	const allModels = state.models?.data ?? [];
 	if (allModels.length === 0) {
 		consola.error(`Upstream returned zero models for account type "${state.accountType}". Verify the account type matches your Copilot plan and that upstream is reachable.`);