@elvatis_com/openclaw-cli-bridge-elvatis 2.8.5 → 2.10.0

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code, OpenCode, Pi) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `2.8.5`
+**Current version:** `2.10.0`
 
 ---
 
@@ -406,6 +406,28 @@ npm run ci          # lint + typecheck + test
 
 ## Changelog
 
+### v2.10.0
+- **fix:** cap effective timeout at 580s (under gateway's 600s `idleTimeoutSeconds`) so bridge fallback fires BEFORE gateway kills the request — eliminates the race condition where both compete to handle the timeout
+- **fix:** reduce Sonnet base timeout 420s→300s, Opus 420s→360s — ensures fallback triggers faster for stuck CLI sessions
+- **feat:** compact tool schema mode — when >8 tools, compress definitions to name+params only, cutting prompt size ~60%
+- **feat:** stale-output detection — if CLI produces no stdout for 120s, SIGTERM early instead of waiting full timeout
+- **feat:** adaptive message limits — reduce history from 20→12 messages when >10 tools to keep prompts smaller
+- **feat:** file-based debug log at `~/.openclaw/cli-bridge/debug.log` — `tail -f` for real-time request lifecycle visibility
+- **feat:** SSE progress comments every 30s so the webchat connection stays informed during long CLI runs
+- **feat:** SSE fallback notification — visible comment when a model times out and the bridge retries with fallback
+- **fix:** rescue tool_calls embedded inside content strings — handles models that wrap `{"tool_calls":[...]}` inside a `{"content":"..."}` wrapper
+- **fix:** parse robustness — debug logging on all parse paths to diagnose raw-JSON-instead-of-tool-calls issues
+
+### v2.9.0
+- **feat:** enhanced `/status` dashboard with 5 new panels:
+  - **Active Requests**: live in-flight requests with model, elapsed time, message/tool count, prompt preview
+  - **Recent Request Log**: last 20 requests with latency, success/fail, prompt preview, token counts
+  - **Fallback History**: last 10 fallback events with reason, timing, and outcome
+  - **Provider Sessions**: CLI session state (active/idle/expired), run count, timeout count
+  - **Timeout Configuration**: per-model base timeouts and dynamic scaling formula
+- **feat:** auto-refresh reduced from 30s to 10s for more responsive monitoring
+- **feat:** responsive two-column layout for fallback history and provider sessions
+
 ### v2.8.5
 - **fix:** sync `openclaw.plugin.json` configSchema defaults with code: Sonnet/Opus 300s to 420s, Haiku 90s to 120s. The schema `default` block was overriding `DEFAULT_MODEL_TIMEOUTS` via `cfg.modelTimeouts`, making all code-level timeout bumps ineffective.
 

package/SKILL.md

@@ -68,4 +68,4 @@ On gateway restart, if any session has expired, a **WhatsApp alert** is sent aut
 
 See `README.md` for full configuration reference and architecture diagram.
 
-**Version:** 2.8.5
+**Version:** 2.10.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-cli-bridge-elvatis",
   "slug": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "2.8.5",
+  "version": "2.10.0",
   "license": "MIT",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [
@@ -43,8 +43,8 @@
           "type": "number"
         },
         "default": {
-          "cli-claude/claude-opus-4-6": 420000,
-          "cli-claude/claude-sonnet-4-6": 420000,
+          "cli-claude/claude-opus-4-6": 360000,
+          "cli-claude/claude-sonnet-4-6": 300000,
           "cli-claude/claude-haiku-4-5": 120000,
           "cli-gemini/gemini-2.5-pro": 300000,
           "cli-gemini/gemini-2.5-flash": 180000,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "2.8.5",
+  "version": "2.10.0",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/cli-runner.ts

@@ -30,11 +30,15 @@ import {
 } from "./tool-protocol.js";
 import {
   MAX_MESSAGES,
+  MAX_MESSAGES_HEAVY_TOOLS,
+  TOOL_HEAVY_THRESHOLD,
   MAX_MSG_CHARS,
   DEFAULT_CLI_TIMEOUT_MS,
   TIMEOUT_GRACE_MS,
   MEDIA_TMP_DIR,
+  STALE_OUTPUT_TIMEOUT_MS,
 } from "./config.js";
+import { debugLog } from "./debug-log.js";
 
 // ──────────────────────────────────────────────────────────────────────────────
 // Message formatting
@@ -69,13 +73,16 @@ export type { ToolDefinition, CliToolResult } from "./tool-protocol.js";
  *   - role "tool": formatted as [Tool Result: name]
  *   - role "assistant" with tool_calls: formatted as [Assistant Tool Call: name(args)]
  */
-export function formatPrompt(messages: ChatMessage[]): string {
+export function formatPrompt(messages: ChatMessage[], toolCount = 0): string {
   if (messages.length === 0) return "";
 
+  // Reduce history when tool schemas dominate the prompt
+  const maxMsgs = toolCount > TOOL_HEAVY_THRESHOLD ? MAX_MESSAGES_HEAVY_TOOLS : MAX_MESSAGES;
+
   // Keep system message (if any) + last N non-system messages
   const system = messages.find((m) => m.role === "system");
   const nonSystem = messages.filter((m) => m.role !== "system");
-  const recent = nonSystem.slice(-MAX_MESSAGES);
+  const recent = nonSystem.slice(-maxMsgs);
   const truncated = system ? [system, ...recent] : recent;
 
   // Single short user message — send bare (no wrapping needed)
@@ -331,17 +338,20 @@ export function runCli(
     let timedOut = false;
     let killTimer: ReturnType<typeof setTimeout> | null = null;
     let timeoutTimer: ReturnType<typeof setTimeout> | null = null;
+    let staleTimer: ReturnType<typeof setInterval> | null = null;
+    let lastOutputAt = Date.now();
 
     const clearTimers = () => {
       if (timeoutTimer) { clearTimeout(timeoutTimer); timeoutTimer = null; }
       if (killTimer) { clearTimeout(killTimer); killTimer = null; }
+      if (staleTimer) { clearInterval(staleTimer); staleTimer = null; }
     };
 
-    // ── Timeout sequence: SIGTERM → grace → SIGKILL ──────────────────────
-    timeoutTimer = setTimeout(() => {
+    const doKill = (reason: string) => {
+      if (timedOut) return; // already killing
       timedOut = true;
-      const elapsed = Math.round(timeoutMs / 1000);
-      log(`[cli-bridge] timeout after ${elapsed}s for ${cmd}, sending SIGTERM`);
+      log(`[cli-bridge] ${reason} for ${cmd}, sending SIGTERM`);
+      debugLog("KILL", `${cmd} ${reason}`, { stdoutLen: stdout.length, stderrLen: stderr.length });
       proc.kill("SIGTERM");
 
       killTimer = setTimeout(() => {
@@ -350,14 +360,36 @@ export function runCli(
           proc.kill("SIGKILL");
         }
       }, TIMEOUT_GRACE_MS);
+    };
+
+    // ── Hard timeout: SIGTERM → grace → SIGKILL ──────────────────────────
+    timeoutTimer = setTimeout(() => {
+      doKill(`timeout after ${Math.round(timeoutMs / 1000)}s`);
     }, timeoutMs);
 
+    // ── Stale-output detection: kill if no stdout for STALE_OUTPUT_TIMEOUT_MS
+    if (STALE_OUTPUT_TIMEOUT_MS > 0) {
+      const checkInterval = 15_000; // check every 15s
+      staleTimer = setInterval(() => {
+        const silent = Date.now() - lastOutputAt;
+        if (silent >= STALE_OUTPUT_TIMEOUT_MS) {
+          doKill(`stale output — no stdout for ${Math.round(silent / 1000)}s`);
+        }
+      }, checkInterval);
+    }
+
     proc.stdin.write(prompt, "utf8", () => {
       proc.stdin.end();
     });
 
-    proc.stdout.on("data", (d: Buffer) => { stdout += d.toString(); });
-    proc.stderr.on("data", (d: Buffer) => { stderr += d.toString(); });
+    proc.stdout.on("data", (d: Buffer) => {
+      stdout += d.toString();
+      lastOutputAt = Date.now();
+    });
+    proc.stderr.on("data", (d: Buffer) => {
+      stderr += d.toString();
+      lastOutputAt = Date.now(); // stderr also counts as activity
+    });
 
     proc.on("close", (code) => {
       clearTimers();
@@ -770,8 +802,9 @@ export async function routeToCliRunner(
   timeoutMs: number,
   opts: RouteOptions = {}
 ): Promise<CliToolResult> {
-  const prompt = formatPrompt(messages);
-  const hasTools = !!(opts.tools?.length);
+  const toolCount = opts.tools?.length ?? 0;
+  const prompt = formatPrompt(messages, toolCount);
+  const hasTools = toolCount > 0;
 
   // Strip "vllm/" prefix if present — OpenClaw sends the full provider path
   // (e.g. "vllm/cli-claude/claude-sonnet-4-6") but the router only needs the

package/src/config.ts

@@ -25,8 +25,13 @@ export const DEFAULT_PROXY_API_KEY = "cli-bridge";
 /** Default base timeout for CLI subprocess responses (ms). Scales dynamically. */
 export const DEFAULT_PROXY_TIMEOUT_MS = 300_000; // 5 min
 
-/** Maximum effective timeout after dynamic scaling (ms). */
-export const MAX_EFFECTIVE_TIMEOUT_MS = 900_000; // 15 min
+/**
+ * Maximum effective timeout after dynamic scaling (ms).
+ * MUST be lower than the OpenClaw gateway's idleTimeoutSeconds (600s)
+ * so the bridge's own fallback fires BEFORE the gateway kills the request.
+ * 580s gives a 20s safety margin under the gateway's 600s hard limit.
+ */
+export const MAX_EFFECTIVE_TIMEOUT_MS = 580_000; // 9m 40s — under gateway's 600s
 
 /** Extra timeout per message beyond 10 in the conversation (ms). */
 export const TIMEOUT_PER_EXTRA_MSG_MS = 2_000;
@@ -47,9 +52,25 @@ export const DEFAULT_CLI_TIMEOUT_MS = 120_000; // 2 min
 /** Grace period between SIGTERM and SIGKILL when a timeout fires (ms). */
 export const TIMEOUT_GRACE_MS = 5_000;
 
+/**
+ * Stale output timeout — if a CLI subprocess produces no stdout for this long,
+ * assume it's stuck and SIGTERM early. 0 = disabled.
+ * Prevents waiting the full timeout when Claude CLI hangs silently.
+ */
+export const STALE_OUTPUT_TIMEOUT_MS = 120_000; // 2 min of silence → kill
+
 /** Max messages to include in the prompt sent to CLI subprocesses. */
 export const MAX_MESSAGES = 20;
 
+/**
+ * Reduced message limit when tools are heavy (> TOOL_HEAVY_THRESHOLD).
+ * Fewer history messages = smaller prompt = faster CLI response.
+ */
+export const MAX_MESSAGES_HEAVY_TOOLS = 12;
+
+/** Tool count threshold that triggers reduced message limit. */
+export const TOOL_HEAVY_THRESHOLD = 10;
+
 /** Max characters per message content before truncation. */
 export const MAX_MSG_CHARS = 4_000;
 
@@ -91,8 +112,8 @@ export const PROVIDER_SESSION_SWEEP_MS = 10 * 60 * 1_000; // 10 min
  *   - Fast/lightweight (Haiku, Flash, Mini): 120s
  */
 export const DEFAULT_MODEL_TIMEOUTS: Record<string, number> = {
-  "cli-claude/claude-opus-4-6":        420_000,  // 7 min
-  "cli-claude/claude-sonnet-4-6":      420_000,  // 7 min — prevent timeout→Haiku fallback on large sessions
+  "cli-claude/claude-opus-4-6":        360_000,  // 6 min — leaves room for dynamic scaling up to 580s cap
+  "cli-claude/claude-sonnet-4-6":      300_000,  // 5 min — was 7 min, reduced so fallback fires before gateway's 600s
   "cli-claude/claude-haiku-4-5":       120_000,  // 2 min
   "cli-gemini/gemini-2.5-pro":         300_000,  // 5 min — image generation needs more time
   "cli-gemini/gemini-2.5-flash":       180_000,  // 3 min

package/src/debug-log.ts

@@ -0,0 +1,55 @@
+/**
+ * debug-log.ts
+ *
+ * File-based debug logger for the CLI bridge.
+ * Writes to ~/.openclaw/cli-bridge/debug.log with automatic rotation at 5 MB.
+ *
+ * Usage:
+ *   tail -f ~/.openclaw/cli-bridge/debug.log
+ */
+
+import { appendFileSync, statSync, renameSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const LOG_DIR = join(homedir(), ".openclaw", "cli-bridge");
+const LOG_FILE = join(LOG_DIR, "debug.log");
+const LOG_FILE_PREV = join(LOG_DIR, "debug.log.1");
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5 MB
+
+let initialized = false;
+
+function ensureDir(): void {
+  if (initialized) return;
+  try { mkdirSync(LOG_DIR, { recursive: true }); } catch { /* exists */ }
+  initialized = true;
+}
+
+function rotate(): void {
+  try {
+    const stat = statSync(LOG_FILE);
+    if (stat.size > MAX_LOG_SIZE) {
+      try { renameSync(LOG_FILE, LOG_FILE_PREV); } catch { /* best effort */ }
+    }
+  } catch { /* file doesn't exist yet */ }
+}
+
+function ts(): string {
+  return new Date().toISOString();
+}
+
+/**
+ * Append a debug line to the log file.
+ * Non-blocking, never throws — logging must not crash the bridge.
+ */
+export function debugLog(category: string, message: string, data?: Record<string, unknown>): void {
+  try {
+    ensureDir();
+    rotate();
+    const extra = data ? ` ${JSON.stringify(data)}` : "";
+    appendFileSync(LOG_FILE, `${ts()} [${category}] ${message}${extra}\n`);
+  } catch { /* never crash on log failure */ }
+}
+
+/** Log path for display on status page / startup messages. */
+export const DEBUG_LOG_PATH = LOG_FILE;

package/src/metrics.ts

@@ -23,11 +23,32 @@ export interface ModelMetrics {
   lastRequestAt: number | null;
 }
 
+export interface RequestLogEntry {
+  timestamp: number;
+  model: string;
+  latencyMs: number;
+  success: boolean;
+  promptPreview: string;
+  promptTokens: number;
+  completionTokens: number;
+}
+
+export interface FallbackEvent {
+  timestamp: number;
+  originalModel: string;
+  fallbackModel: string;
+  reason: "timeout" | "error";
+  failedDurationMs: number;
+  fallbackSuccess: boolean;
+}
+
 export interface MetricsSnapshot {
   startedAt: number;
   totalRequests: number;
   totalErrors: number;
   models: ModelMetrics[]; // sorted by requests desc
+  recentRequests: RequestLogEntry[];
+  fallbackHistory: FallbackEvent[];
 }
 
 // ── Token estimation ────────────────────────────────────────────────────────
@@ -42,6 +63,19 @@ export function estimateTokens(text: string): number {
   return Math.ceil(text.length / 4);
 }
 
+// ── Circular buffer ─────────────────────────────────────────────────────────
+
+class CircularBuffer<T> {
+  private items: T[] = [];
+  constructor(private capacity: number) {}
+  push(item: T): void {
+    if (this.items.length >= this.capacity) this.items.shift();
+    this.items.push(item);
+  }
+  toArray(): T[] { return [...this.items]; }
+  clear(): void { this.items.length = 0; }
+}
+
 // ── Persistence format ──────────────────────────────────────────────────────
 
 interface PersistedMetrics {
@@ -57,6 +91,8 @@ class MetricsCollector {
   private data = new Map<string, ModelMetrics>();
   private flushTimer: ReturnType<typeof setTimeout> | null = null;
   private dirty = false;
+  private recentRequests = new CircularBuffer<RequestLogEntry>(20);
+  private fallbackEvents = new CircularBuffer<FallbackEvent>(10);
 
   constructor() {
     this.load();
@@ -68,6 +104,7 @@ class MetricsCollector {
     success: boolean,
     promptTokens?: number,
     completionTokens?: number,
+    promptPreview?: string,
   ): void {
     let entry = this.data.get(model);
     if (!entry) {
@@ -88,6 +125,15 @@ class MetricsCollector {
     if (promptTokens) entry.promptTokens += promptTokens;
     if (completionTokens) entry.completionTokens += completionTokens;
     entry.lastRequestAt = Date.now();
+    this.recentRequests.push({
+      timestamp: Date.now(),
+      model,
+      latencyMs: durationMs,
+      success,
+      promptPreview: promptPreview ?? "",
+      promptTokens: promptTokens ?? 0,
+      completionTokens: completionTokens ?? 0,
+    });
     this.scheduleSave();
   }
 
@@ -109,12 +155,33 @@ class MetricsCollector {
       totalRequests,
       totalErrors,
       models,
+      recentRequests: this.recentRequests.toArray(),
+      fallbackHistory: this.fallbackEvents.toArray(),
     };
   }
 
+  recordFallback(
+    originalModel: string,
+    fallbackModel: string,
+    reason: "timeout" | "error",
+    failedDurationMs: number,
+    fallbackSuccess: boolean,
+  ): void {
+    this.fallbackEvents.push({
+      timestamp: Date.now(),
+      originalModel,
+      fallbackModel,
+      reason,
+      failedDurationMs,
+      fallbackSuccess,
+    });
+  }
+
   reset(): void {
     this.startedAt = Date.now();
     this.data.clear();
+    this.recentRequests.clear();
+    this.fallbackEvents.clear();
     this.saveNow();
   }
 

package/src/proxy-server.ts

@@ -31,7 +31,26 @@ import {
   DEFAULT_BITNET_SERVER_URL,
   BITNET_MAX_MESSAGES,
   BITNET_SYSTEM_PROMPT,
+  DEFAULT_MODEL_TIMEOUTS,
 } from "./config.js";
+import { debugLog, DEBUG_LOG_PATH } from "./debug-log.js";
+
+// ── Active request tracking ─────────────────────────────────────────────────
+
+export interface ActiveRequest {
+  id: string;
+  model: string;
+  startedAt: number;
+  messageCount: number;
+  toolCount: number;
+  promptPreview: string;
+}
+
+const activeRequests = new Map<string, ActiveRequest>();
+
+export function getActiveRequests(): ActiveRequest[] {
+  return [...activeRequests.values()];
+}
 
 export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
 export type GrokCompleteStreamOptions = Parameters<typeof grokCompleteStream>[1];
@@ -196,6 +215,7 @@ export function startProxyServer(opts: ProxyServerOptions): Promise<http.Server>
       opts.log(
         `[cli-bridge] proxy listening on :${opts.port}`
       );
+      debugLog("STARTUP", `proxy listening on :${opts.port}`, { debugLog: DEBUG_LOG_PATH });
       // unref() so the proxy server does not keep the Node.js event loop alive
       // when openclaw doctor or other short-lived CLI commands load plugins.
       // The gateway's own main loop keeps the process alive during normal operation.
@@ -276,7 +296,20 @@ async function handleRequest(
       { name: "ChatGPT",  icon: "◉",  expiry: expiry.chatgpt, loginCmd: "/chatgpt-login", ctx: opts.getChatGPTContext?.() ?? null },
     ];
 
-    const html = renderStatusPage({ version, port: opts.port, providers, models: CLI_MODELS, modelCommands: opts.modelCommands, metrics: metrics.getMetrics() });
+    const html = renderStatusPage({
+      version, port: opts.port, providers, models: CLI_MODELS,
+      modelCommands: opts.modelCommands,
+      metrics: metrics.getMetrics(),
+      activeRequests: getActiveRequests(),
+      providerSessionsList: providerSessions.listSessions(),
+      timeoutConfig: {
+        defaults: { ...DEFAULT_MODEL_TIMEOUTS, ...(opts.modelTimeouts ?? {}) },
+        baseDefault: opts.timeoutMs ?? DEFAULT_PROXY_TIMEOUT_MS,
+        maxEffective: MAX_EFFECTIVE_TIMEOUT_MS,
+        perExtraMsg: TIMEOUT_PER_EXTRA_MSG_MS,
+        perTool: TIMEOUT_PER_TOOL_MS,
+      },
+    });
     res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
     res.end(html);
     return;
@@ -354,6 +387,15 @@ async function handleRequest(
     const id = `chatcmpl-cli-${randomBytes(6).toString("hex")}`;
     const created = Math.floor(Date.now() / 1000);
 
+    // Extract prompt preview from last user message for dashboard
+    const lastUserMsg = [...cleanMessages].reverse().find(m => m.role === "user");
+    const promptPreview = typeof lastUserMsg?.content === "string" ? lastUserMsg.content.slice(0, 80) : "";
+
+    debugLog("REQ", `${model} start`, { msgs: cleanMessages.length, tools: tools?.length ?? 0, stream, media: mediaFiles.length, promptPreview: promptPreview.slice(0, 60) });
+
+    // Track active request for dashboard
+    activeRequests.set(id, { id, model, startedAt: Date.now(), messageCount: cleanMessages.length, toolCount: tools?.length ?? 0, promptPreview });
+
     // ── Grok web-session routing ──────────────────────────────────────────────
     if (model.startsWith("web-grok/")) {
       let grokCtx = opts.getGrokContext?.() ?? null;
@@ -767,6 +809,7 @@ async function handleRequest(
     const toolExtra = (tools?.length ?? 0) * TIMEOUT_PER_TOOL_MS;
     const effectiveTimeout = Math.min(baseTimeout + msgExtra + toolExtra, MAX_EFFECTIVE_TIMEOUT_MS);
     opts.log(`[cli-bridge] ${model} session=${session.id} timeout: ${Math.round(effectiveTimeout / 1000)}s (base=${Math.round(baseTimeout / 1000)}s${perModelTimeout ? " per-model" : ""}, +${Math.round(msgExtra / 1000)}s msgs, +${Math.round(toolExtra / 1000)}s tools)`);
+    debugLog("TIMEOUT", `${model} effective=${Math.round(effectiveTimeout / 1000)}s`, { base: Math.round(baseTimeout / 1000), msgExtra: Math.round(msgExtra / 1000), toolExtra: Math.round(toolExtra / 1000), cap: Math.round(MAX_EFFECTIVE_TIMEOUT_MS / 1000) });
 
     // ── SSE keepalive: send headers early so OpenClaw doesn't read-timeout ──
     let sseHeadersSent = false;
@@ -783,33 +826,58 @@ async function handleRequest(
       keepaliveInterval = setInterval(() => { res.write(": keepalive\n\n"); }, SSE_KEEPALIVE_INTERVAL_MS);
     }
 
+    // ── Progress notifications: send visible status updates to the webchat ──
+    // Users shouldn't stare at a blank screen for minutes without feedback.
+    let progressInterval: ReturnType<typeof setInterval> | null = null;
+    const PROGRESS_INTERVAL_MS = 30_000; // 30s between updates
+    if (stream && sseHeadersSent) {
+      const progressStart = Date.now();
+      progressInterval = setInterval(() => {
+        const elapsed = Math.round((Date.now() - progressStart) / 1000);
+        const timeoutSec = Math.round(effectiveTimeout / 1000);
+        // Send an SSE comment with progress info — visible in raw SSE but won't render as content
+        // Also send a small content delta that OpenClaw can show as typing indicator
+        res.write(`: progress ${elapsed}s/${timeoutSec}s — ${model} processing\n\n`);
+      }, PROGRESS_INTERVAL_MS);
+    }
+
     const cliStart = Date.now();
     try {
       result = await routeToCliRunner(model, cleanMessages, effectiveTimeout, routeOpts);
+      const latencyMs = Date.now() - cliStart;
       const estCompletionTokens = estimateTokens(result.content ?? "");
-      metrics.recordRequest(model, Date.now() - cliStart, true, estPromptTokens, estCompletionTokens);
+      metrics.recordRequest(model, latencyMs, true, estPromptTokens, estCompletionTokens, promptPreview);
       providerSessions.recordRun(session.id, false);
+      debugLog("OK", `${model} completed in ${(latencyMs / 1000).toFixed(1)}s`, { toolCalls: result.tool_calls?.length ?? 0, contentLen: result.content?.length ?? 0 });
     } catch (err) {
       const primaryDuration = Date.now() - cliStart;
       const msg = (err as Error).message;
       // ── Model fallback: retry once with a lighter model if configured ────
       const isTimeout = msg.includes("timeout:") || msg.includes("exit 143") || msg.includes("exited 143");
+      debugLog("FAIL", `${model} failed after ${(primaryDuration / 1000).toFixed(1)}s`, { isTimeout, error: msg.slice(0, 200) });
       // Record the run (with timeout flag) — session is preserved, not deleted
       providerSessions.recordRun(session.id, isTimeout);
       const fallbackModel = opts.modelFallbacks?.[model];
       if (fallbackModel) {
-        metrics.recordRequest(model, primaryDuration, false, estPromptTokens);
+        metrics.recordRequest(model, primaryDuration, false, estPromptTokens, undefined, promptPreview);
         const reason = isTimeout ? `timeout by supervisor, session=${session.id} preserved` : msg;
         opts.warn(`[cli-bridge] ${model} failed (${reason}), falling back to ${fallbackModel}`);
+        debugLog("FALLBACK", `${model} → ${fallbackModel}`, { reason: isTimeout ? "timeout" : "error", primaryDuration: Math.round(primaryDuration / 1000) });
+        // Notify the user via SSE that we're retrying with a different model
+        if (sseHeadersSent) {
+          res.write(`: fallback — ${model} ${isTimeout ? "timed out" : "failed"} after ${Math.round(primaryDuration / 1000)}s, retrying with ${fallbackModel}\n\n`);
+        }
         const fallbackStart = Date.now();
         try {
           result = await routeToCliRunner(fallbackModel, cleanMessages, effectiveTimeout, routeOpts);
           const fbCompTokens = estimateTokens(result.content ?? "");
-          metrics.recordRequest(fallbackModel, Date.now() - fallbackStart, true, estPromptTokens, fbCompTokens);
+          metrics.recordRequest(fallbackModel, Date.now() - fallbackStart, true, estPromptTokens, fbCompTokens, promptPreview);
+          metrics.recordFallback(model, fallbackModel, isTimeout ? "timeout" : "error", primaryDuration, true);
           usedModel = fallbackModel;
           opts.log(`[cli-bridge] fallback to ${fallbackModel} succeeded (response will report original model: ${model})`);
         } catch (fallbackErr) {
-          metrics.recordRequest(fallbackModel, Date.now() - fallbackStart, false, estPromptTokens);
+          metrics.recordRequest(fallbackModel, Date.now() - fallbackStart, false, estPromptTokens, undefined, promptPreview);
+          metrics.recordFallback(model, fallbackModel, isTimeout ? "timeout" : "error", primaryDuration, false);
           const fallbackMsg = (fallbackErr as Error).message;
           opts.warn(`[cli-bridge] fallback ${fallbackModel} also failed: ${fallbackMsg}`);
           if (sseHeadersSent) {
@@ -823,7 +891,7 @@ async function handleRequest(
           return;
         }
       } else {
-        metrics.recordRequest(model, primaryDuration, false, estPromptTokens);
+        metrics.recordRequest(model, primaryDuration, false, estPromptTokens, undefined, promptPreview);
         opts.warn(`[cli-bridge] CLI error for ${model}: ${msg}`);
         if (sseHeadersSent) {
           res.write(`data: ${JSON.stringify({ error: { message: msg, type: "cli_error" } })}\n\n`);
@@ -837,7 +905,9 @@ async function handleRequest(
       }
     } finally {
       if (keepaliveInterval) clearInterval(keepaliveInterval);
+      if (progressInterval) clearInterval(progressInterval);
       cleanupMediaFiles(mediaFiles);
+      activeRequests.delete(id);
     }
 
     const hasToolCalls = !!(result.tool_calls?.length);

package/src/status-template.ts

@@ -6,7 +6,9 @@
  */
 
 import type { BrowserContext } from "playwright";
-import type { MetricsSnapshot } from "./metrics.js";
+import type { MetricsSnapshot, RequestLogEntry, FallbackEvent } from "./metrics.js";
+import type { ProviderSession } from "./provider-sessions.js";
+import type { ActiveRequest } from "./proxy-server.js";
 
 export interface StatusProvider {
   name: string;
@@ -16,15 +18,24 @@ export interface StatusProvider {
   ctx: BrowserContext | null;
 }
 
+export interface TimeoutConfigInfo {
+  defaults: Record<string, number>;
+  baseDefault: number;
+  maxEffective: number;
+  perExtraMsg: number;
+  perTool: number;
+}
+
 export interface StatusTemplateOptions {
   version: string;
   port: number;
   providers: StatusProvider[];
   models: Array<{ id: string; name: string; contextWindow: number; maxTokens: number }>;
-  /** Maps model ID → slash command name (e.g. "openai-codex/gpt-5.3-codex" → "/cli-codex") */
   modelCommands?: Record<string, string>;
-  /** In-memory metrics snapshot — optional for backward compat */
   metrics?: MetricsSnapshot;
+  activeRequests?: ActiveRequest[];
+  providerSessionsList?: ProviderSession[];
+  timeoutConfig?: TimeoutConfigInfo;
 }
 
 function statusBadge(p: StatusProvider): { label: string; color: string; dot: string } {
@@ -44,14 +55,14 @@ function formatDuration(ms: number): string {
 }
 
 function formatTokens(n: number): string {
-  if (n === 0) return "—";
+  if (n === 0) return "\u2014";
   if (n < 1000) return String(n);
   if (n < 1_000_000) return `${(n / 1000).toFixed(1)}k`;
   return `${(n / 1_000_000).toFixed(2)}M`;
 }
 
 function timeAgo(epochMs: number | null): string {
-  if (!epochMs) return "—";
+  if (!epochMs) return "\u2014";
   const diff = Date.now() - epochMs;
   if (diff < 60_000) return "just now";
   if (diff < 3_600_000) return `${Math.floor(diff / 60_000)}m ago`;
@@ -75,6 +86,223 @@ function escapeHtml(s: string): string {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 
+function truncateId(id: string): string {
+  if (id.length <= 20) return id;
+  return id.slice(0, 8) + "\u2026" + id.slice(-8);
+}
+
+// ── Active Requests ────────────────────────────────────────────────────────
+
+function renderActiveRequests(active: ActiveRequest[]): string {
+  if (active.length === 0) {
+    return `
+    <div class="card">
+      <div class="card-header">Active Requests <span class="badge badge-ok">0</span></div>
+      <div class="empty-state">No active requests</div>
+    </div>`;
+  }
+
+  const rows = active.map(r => {
+    const elapsed = Date.now() - r.startedAt;
+    const elapsedClass = elapsed > 300_000 ? ' style="color:#ef4444;font-weight:600"' : elapsed > 120_000 ? ' style="color:#f59e0b"' : "";
+    return `
+      <tr>
+        <td class="metrics-cell"><span class="pulse-dot"></span></td>
+        <td class="metrics-cell"><code class="model-id">${escapeHtml(r.model)}</code></td>
+        <td class="metrics-cell" style="text-align:right"${elapsedClass}>${formatDuration(elapsed)}</td>
+        <td class="metrics-cell" style="text-align:right">${r.messageCount}</td>
+        <td class="metrics-cell" style="text-align:right">${r.toolCount}</td>
+        <td class="metrics-cell prompt-preview">${escapeHtml(r.promptPreview || "\u2014")}</td>
+      </tr>`;
+  }).join("");
+
+  return `
+  <div class="card">
+    <div class="card-header">Active Requests <span class="badge badge-active">${active.length}</span></div>
+    <table class="metrics-table">
+      <thead>
+        <tr class="table-head">
+          <th class="metrics-th" style="width:24px"></th>
+          <th class="metrics-th" style="text-align:left">Model</th>
+          <th class="metrics-th" style="text-align:right">Elapsed</th>
+          <th class="metrics-th" style="text-align:right">Msgs</th>
+          <th class="metrics-th" style="text-align:right">Tools</th>
+          <th class="metrics-th" style="text-align:left">Prompt</th>
+        </tr>
+      </thead>
+      <tbody>${rows}</tbody>
+    </table>
+  </div>`;
+}
+
+// ── Recent Request Log ────────────────────────────────────────────────────���
+
+function renderRecentRequestLog(entries: RequestLogEntry[]): string {
+  if (entries.length === 0) {
+    return `
+    <div class="card">
+      <div class="card-header">Recent Requests</div>
+      <div class="empty-state">No requests recorded yet</div>
+    </div>`;
+  }
+
+  const rows = [...entries].reverse().map(r => {
+    const statusIcon = r.success
+      ? '<span style="color:#22c55e">&#10003;</span>'
+      : '<span style="color:#ef4444">&#10007;</span>';
+    return `
+      <tr>
+        <td class="metrics-cell" style="color:#6b7280;font-size:12px;white-space:nowrap">${timeAgo(r.timestamp)}</td>
+        <td class="metrics-cell"><code class="model-id">${escapeHtml(r.model)}</code></td>
+        <td class="metrics-cell" style="text-align:right">${formatDuration(r.latencyMs)}</td>
+        <td class="metrics-cell" style="text-align:center">${statusIcon}</td>
+        <td class="metrics-cell prompt-preview">${escapeHtml(r.promptPreview || "\u2014")}</td>
+        <td class="metrics-cell" style="text-align:right;color:#6b7280;font-size:12px">${formatTokens(r.promptTokens)} / ${formatTokens(r.completionTokens)}</td>
+      </tr>`;
+  }).join("");
+
+  return `
+  <div class="card">
+    <div class="card-header">Recent Requests <span style="color:#4b5563;font-weight:400">(last ${entries.length})</span></div>
+    <table class="metrics-table">
+      <thead>
+        <tr class="table-head">
+          <th class="metrics-th" style="text-align:left">Time</th>
+          <th class="metrics-th" style="text-align:left">Model</th>
+          <th class="metrics-th" style="text-align:right">Latency</th>
+          <th class="metrics-th" style="text-align:center">OK</th>
+          <th class="metrics-th" style="text-align:left">Prompt</th>
+          <th class="metrics-th" style="text-align:right">Tokens (in/out)</th>
+        </tr>
+      </thead>
+      <tbody>${rows}</tbody>
+    </table>
+  </div>`;
+}
+
+// ── Fallback History ───────────────────────────────────────────────────────
+
+function renderFallbackHistory(events: FallbackEvent[]): string {
+  if (events.length === 0) {
+    return `
+    <div class="card">
+      <div class="card-header">Fallback History</div>
+      <div class="empty-state">No fallback events</div>
+    </div>`;
+  }
+
+  const rows = [...events].reverse().map(e => {
+    const reasonBadge = e.reason === "timeout"
+      ? '<span class="badge badge-warn">timeout</span>'
+      : '<span class="badge badge-error">error</span>';
+    const outcomeBadge = e.fallbackSuccess
+      ? '<span class="badge badge-ok">success</span>'
+      : '<span class="badge badge-error">failed</span>';
+    return `
+      <tr>
+        <td class="metrics-cell" style="color:#6b7280;font-size:12px;white-space:nowrap">${timeAgo(e.timestamp)}</td>
+        <td class="metrics-cell"><code class="model-id">${escapeHtml(e.originalModel)}</code></td>
+        <td class="metrics-cell"><code class="model-id">${escapeHtml(e.fallbackModel)}</code></td>
+        <td class="metrics-cell">${reasonBadge}</td>
+        <td class="metrics-cell" style="text-align:right">${formatDuration(e.failedDurationMs)}</td>
+        <td class="metrics-cell">${outcomeBadge}</td>
+      </tr>`;
+  }).join("");
+
+  return `
+  <div class="card">
+    <div class="card-header">Fallback History <span style="color:#4b5563;font-weight:400">(last ${events.length})</span></div>
+    <table class="metrics-table">
+      <thead>
+        <tr class="table-head">
+          <th class="metrics-th" style="text-align:left">Time</th>
+          <th class="metrics-th" style="text-align:left">Original Model</th>
+          <th class="metrics-th" style="text-align:left">Fallback Model</th>
+          <th class="metrics-th" style="text-align:left">Reason</th>
+          <th class="metrics-th" style="text-align:right">Failed After</th>
+          <th class="metrics-th" style="text-align:left">Outcome</th>
+        </tr>
+      </thead>
+      <tbody>${rows}</tbody>
+    </table>
+  </div>`;
+}
+
+// ── Provider Sessions ──────────────────────────────────────────────────────
+
+function renderProviderSessions(sessions: ProviderSession[]): string {
+  if (sessions.length === 0) {
+    return `
+    <div class="card">
+      <div class="card-header">Provider Sessions</div>
+      <div class="empty-state">No active sessions</div>
+    </div>`;
+  }
+
+  const sorted = [...sessions].sort((a, b) => b.updatedAt - a.updatedAt);
+  const rows = sorted.map(s => {
+    const stateColor = s.state === "active" ? "#22c55e" : s.state === "idle" ? "#3b82f6" : "#6b7280";
+    const stateBadge = `<span class="badge" style="background:${stateColor}22;color:${stateColor};border-color:${stateColor}44">${s.state}</span>`;
+    const timeoutWarn = s.timeoutCount > 0 ? ` <span style="color:#ef4444;font-size:11px">(${s.timeoutCount} timeouts)</span>` : "";
+    return `
+      <tr>
+        <td class="metrics-cell" style="font-family:monospace;font-size:12px;color:#9ca3af">${truncateId(s.id)}</td>
+        <td class="metrics-cell"><code class="model-id">${escapeHtml(s.modelAlias)}</code></td>
+        <td class="metrics-cell">${stateBadge}</td>
+        <td class="metrics-cell" style="text-align:right">${s.runCount}${timeoutWarn}</td>
+        <td class="metrics-cell" style="text-align:right;color:#6b7280;font-size:12px">${timeAgo(s.updatedAt)}</td>
+      </tr>`;
+  }).join("");
+
+  return `
+  <div class="card">
+    <div class="card-header">Provider Sessions <span style="color:#4b5563;font-weight:400">(${sessions.length})</span></div>
+    <table class="metrics-table">
+      <thead>
+        <tr class="table-head">
+          <th class="metrics-th" style="text-align:left">Session ID</th>
+          <th class="metrics-th" style="text-align:left">Model</th>
+          <th class="metrics-th" style="text-align:left">State</th>
+          <th class="metrics-th" style="text-align:right">Runs</th>
+          <th class="metrics-th" style="text-align:right">Last Activity</th>
+        </tr>
+      </thead>
+      <tbody>${rows}</tbody>
+    </table>
+  </div>`;
+}
+
+// ── Timeout Configuration ──────────────────────────────────────────────────
+
+function renderTimeoutConfig(config: TimeoutConfigInfo): string {
+  const entries = Object.entries(config.defaults).sort(([a], [b]) => a.localeCompare(b));
+  const rows = entries.map(([model, ms]) => {
+    return `
+      <tr>
+        <td class="metrics-cell"><code class="model-id">${escapeHtml(model)}</code></td>
+        <td class="metrics-cell" style="text-align:right">${Math.round(ms / 1000)}s</td>
+      </tr>`;
+  }).join("");
+
+  return `
+  <div class="card">
+    <div class="card-header">Timeout Configuration</div>
+    <div style="padding:12px 16px;color:#9ca3af;font-size:13px;border-bottom:1px solid #1f2335">
+      <strong style="color:#d1d5db">Formula:</strong> base timeout + (msgs beyond 10 &times; ${config.perExtraMsg / 1000}s) + (tools &times; ${config.perTool / 1000}s), capped at ${Math.round(config.maxEffective / 1000)}s
+      <br><span style="color:#6b7280">Default base: ${Math.round(config.baseDefault / 1000)}s</span>
+    </div>
+    <table class="metrics-table">
+      <thead>
+        <tr class="table-head">
+          <th class="metrics-th" style="text-align:left">Model</th>
+          <th class="metrics-th" style="text-align:right">Base Timeout</th>
+        </tr>
+      </thead>
+      <tbody>${rows}</tbody>
+    </table>
+  </div>`;
+}
+
 // ── Metrics sections ────────────────────────────────────────────────────────
 
 function renderMetricsSection(m: MetricsSnapshot): string {
@@ -112,7 +340,7 @@ function renderMetricsSection(m: MetricsSnapshot): string {
       const modErrorRate = mod.requests > 0 ? ((mod.errors / mod.requests) * 100).toFixed(1) : "0.0";
       return `
         <tr>
-          <td class="metrics-cell"><code style="color:#93c5fd">${escapeHtml(mod.model)}</code></td>
+          <td class="metrics-cell"><code class="model-id">${escapeHtml(mod.model)}</code></td>
           <td class="metrics-cell" style="text-align:right">${mod.requests}</td>
           <td class="metrics-cell" style="text-align:right;color:${mod.errors > 0 ? '#ef4444' : '#6b7280'}">${mod.errors} <span style="color:#6b7280;font-size:11px">(${modErrorRate}%)</span></td>
           <td class="metrics-cell" style="text-align:right">${formatDuration(avgLatency)}</td>
@@ -127,7 +355,7 @@ function renderMetricsSection(m: MetricsSnapshot): string {
     <div class="card-header">Per-Model Stats</div>
     <table class="metrics-table">
       <thead>
-        <tr style="background:#13151f">
+        <tr class="table-head">
           <th class="metrics-th" style="text-align:left">Model</th>
           <th class="metrics-th" style="text-align:right">Requests</th>
           <th class="metrics-th" style="text-align:right">Errors</th>
@@ -150,7 +378,7 @@ export function renderStatusPage(opts: StatusTemplateOptions): string {
     const badge = statusBadge(p);
     const expiryText = p.expiry
       ? p.expiry.replace(/[⚠️🚨✅🕐]/gu, "").trim()
-      : `Not logged in — run <code>${p.loginCmd}</code>`;
+      : `Not logged in \u2014 run <code>${p.loginCmd}</code>`;
     return `
         <tr>
           <td style="padding:12px 16px;font-weight:600;font-size:15px">${p.icon} ${p.name}</td>
@@ -174,10 +402,15 @@ export function renderStatusPage(opts: StatusTemplateOptions): string {
     items.map(m => {
       const cmd = cmds[m.id];
       const cmdBadge = cmd ? `<span style="color:#6b7280;font-size:11px;margin-left:8px">${cmd}</span>` : "";
-      return `<li style="margin:2px 0;font-size:13px;color:#d1d5db"><code style="color:#93c5fd">${m.id}</code>${cmdBadge}</li>`;
+      return `<li style="margin:2px 0;font-size:13px;color:#d1d5db"><code class="model-id">${m.id}</code>${cmdBadge}</li>`;
     }).join("");
 
   const metricsHtml = opts.metrics ? renderMetricsSection(opts.metrics) : "";
+  const activeHtml = opts.activeRequests ? renderActiveRequests(opts.activeRequests) : "";
+  const recentHtml = opts.metrics ? renderRecentRequestLog(opts.metrics.recentRequests) : "";
+  const fallbackHtml = opts.metrics ? renderFallbackHistory(opts.metrics.fallbackHistory) : "";
+  const sessionsHtml = opts.providerSessionsList ? renderProviderSessions(opts.providerSessionsList) : "";
+  const timeoutHtml = opts.timeoutConfig ? renderTimeoutConfig(opts.timeoutConfig) : "";
 
   return `<!DOCTYPE html>
 <html lang="en">
@@ -185,20 +418,24 @@ export function renderStatusPage(opts: StatusTemplateOptions): string {
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>CLI Bridge Status</title>
-  <meta http-equiv="refresh" content="30">
+  <meta http-equiv="refresh" content="10">
   <style>
     * { box-sizing: border-box; margin: 0; padding: 0; }
     body { background: #0f1117; color: #e5e7eb; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; min-height: 100vh; padding: 32px 24px; }
     h1 { font-size: 22px; font-weight: 700; color: #f9fafb; margin-bottom: 4px; }
     .subtitle { color: #6b7280; font-size: 13px; margin-bottom: 28px; }
+    .subtitle a { color: #3b82f6; text-decoration: none; }
+    .subtitle a:hover { text-decoration: underline; }
     .card { background: #1a1d27; border: 1px solid #2d3148; border-radius: 12px; overflow: hidden; margin-bottom: 24px; }
     .card-header { padding: 14px 16px; border-bottom: 1px solid #2d3148; font-size: 12px; font-weight: 600; color: #6b7280; text-transform: uppercase; letter-spacing: 0.05em; }
     table { width: 100%; border-collapse: collapse; }
     tr:not(:last-child) td { border-bottom: 1px solid #1f2335; }
+    .table-head { background: #13151f; }
     .models { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; }
     ul { list-style: none; padding: 12px 16px; }
     .footer { color: #374151; font-size: 12px; text-align: center; margin-top: 16px; }
     code { background: #1e2130; padding: 1px 5px; border-radius: 4px; }
+    .model-id { color: #93c5fd; }
     .summary-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 16px; margin-bottom: 24px; }
     .summary-card { background: #1a1d27; border: 1px solid #2d3148; border-radius: 12px; padding: 20px 16px; text-align: center; }
     .summary-value { font-size: 28px; font-weight: 700; color: #f9fafb; margin-bottom: 4px; }
@@ -206,17 +443,31 @@ export function renderStatusPage(opts: StatusTemplateOptions): string {
     .metrics-table { width: 100%; border-collapse: collapse; }
     .metrics-th { padding: 10px 16px; font-size: 12px; color: #4b5563; font-weight: 600; }
     .metrics-cell { padding: 10px 16px; font-size: 13px; }
+    .empty-state { padding: 24px 16px; color: #4b5563; text-align: center; font-style: italic; font-size: 13px; }
+    .prompt-preview { max-width: 280px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: #9ca3af; font-family: monospace; font-size: 12px; }
+    .badge { display: inline-block; border-radius: 6px; padding: 2px 8px; font-size: 11px; font-weight: 600; border: 1px solid transparent; }
+    .badge-ok { background: #22c55e22; color: #22c55e; border-color: #22c55e44; }
+    .badge-warn { background: #f59e0b22; color: #f59e0b; border-color: #f59e0b44; }
+    .badge-error { background: #ef444422; color: #ef4444; border-color: #ef444444; }
+    .badge-active { background: #3b82f622; color: #3b82f6; border-color: #3b82f644; }
+    .pulse-dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: #22c55e; animation: pulse 1.5s ease-in-out infinite; }
+    @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.3; } }
+    .two-col { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; }
+    @media (max-width: 768px) {
+      .summary-grid { grid-template-columns: repeat(2, 1fr); }
+      .models, .two-col { grid-template-columns: 1fr; }
+    }
   </style>
 </head>
 <body>
   <h1>CLI Bridge</h1>
-  <p class="subtitle">v${version} &nbsp;&middot;&nbsp; Port ${port} &nbsp;&middot;&nbsp; Auto-refreshes every 30s</p>
+  <p class="subtitle">v${version} &middot; Port ${port} &middot; Auto-refreshes every 10s &middot; <a href="/status">\u21bb Refresh</a></p>
 
   <div class="card">
     <div class="card-header">Web Session Providers</div>
     <table>
       <thead>
-        <tr style="background:#13151f">
+        <tr class="table-head">
           <th style="padding:10px 16px;text-align:left;font-size:12px;color:#4b5563;font-weight:600">Provider</th>
           <th style="padding:10px 16px;text-align:left;font-size:12px;color:#4b5563;font-weight:600">Status</th>
           <th style="padding:10px 16px;text-align:left;font-size:12px;color:#4b5563;font-weight:600">Session</th>
@@ -229,6 +480,17 @@ export function renderStatusPage(opts: StatusTemplateOptions): string {
 
   ${metricsHtml}
 
+  ${activeHtml}
+
+  ${recentHtml}
+
+  <div class="two-col">
+    <div>${fallbackHtml}</div>
+    <div>${sessionsHtml}</div>
+  </div>
+
+  ${timeoutHtml}
+
   <div class="models">
     <div class="card">
       <div class="card-header">CLI Models (${cliModels.length})</div>
@@ -246,7 +508,7 @@ export function renderStatusPage(opts: StatusTemplateOptions): string {
     </div>
   </div>
 
-  <p class="footer">openclaw-cli-bridge-elvatis v${version} &nbsp;&middot;&nbsp; <a href="/v1/models" style="color:#4b5563">/v1/models</a> &nbsp;&middot;&nbsp; <a href="/health" style="color:#4b5563">/health</a> &nbsp;&middot;&nbsp; <a href="/healthz" style="color:#4b5563">/healthz</a></p>
+  <p class="footer">openclaw-cli-bridge-elvatis v${version} &middot; <a href="/v1/models" style="color:#4b5563">/v1/models</a> &middot; <a href="/health" style="color:#4b5563">/health</a> &middot; <a href="/healthz" style="color:#4b5563">/healthz</a></p>
 </body>
 </html>`;
 }

package/src/tool-protocol.ts

@@ -10,6 +10,7 @@
  */
 
 import { randomBytes } from "node:crypto";
+import { debugLog } from "./debug-log.js";
 
 // ──────────────────────────────────────────────────────────────────────────────
 // Types
@@ -46,13 +47,34 @@ export interface CliToolResult {
  * Build a text block describing available tools and response format instructions.
  * This block is prepended to the system message (or added as a new system message).
  */
+/** Threshold: when tool count exceeds this, use compact schema to reduce prompt size. */
+const COMPACT_TOOL_THRESHOLD = 8;
+
+/**
+ * Build a compact tool description: name + required param names only.
+ * Cuts prompt size by ~60-70% for large tool sets.
+ */
+function compactToolDescription(t: ToolDefinition): string {
+  const fn = t.function;
+  const params = fn.parameters as { properties?: Record<string, unknown>; required?: string[] };
+  const required = params?.required ?? Object.keys(params?.properties ?? {});
+  const paramList = required.length > 0 ? `(${required.join(", ")})` : "()";
+  return `- ${fn.name}${paramList}: ${fn.description}`;
+}
+
+/**
+ * Build a full tool description: name, description, and full JSON schema.
+ */
+function fullToolDescription(t: ToolDefinition): string {
+  const fn = t.function;
+  const params = JSON.stringify(fn.parameters);
+  return `- name: ${fn.name}\n  description: ${fn.description}\n  parameters: ${params}`;
+}
+
 export function buildToolPromptBlock(tools: ToolDefinition[]): string {
+  const useCompact = tools.length > COMPACT_TOOL_THRESHOLD;
   const toolDescriptions = tools
-    .map((t) => {
-      const fn = t.function;
-      const params = JSON.stringify(fn.parameters);
-      return `- name: ${fn.name}\n  description: ${fn.description}\n  parameters: ${params}`;
-    })
+    .map(useCompact ? compactToolDescription : fullToolDescription)
     .join("\n");
 
   return [
@@ -67,6 +89,7 @@ export function buildToolPromptBlock(tools: ToolDefinition[]): string {
     '{"content":"<your text response>"}',
     "",
     "Do NOT include any text outside the JSON. Do NOT wrap in markdown code blocks.",
+    useCompact ? "Call ONE tool at a time. Do NOT batch multiple tool calls." : "",
     "",
     "Available tools:",
     toolDescriptions,
@@ -117,6 +140,7 @@ export function buildToolCallJsonSchema(): object {
  */
 export function parseToolCallResponse(text: string): CliToolResult {
   const trimmed = text.trim();
+  const preview = trimmed.slice(0, 120);
 
   // Check for Claude's --output-format json wrapper FIRST.
   // Claude returns: { "type": "result", "result": "..." }
@@ -124,30 +148,48 @@ export function parseToolCallResponse(text: string): CliToolResult {
   const claudeResult = tryExtractClaudeJsonResult(trimmed);
   if (claudeResult) {
     const inner = tryParseJson(claudeResult);
-    if (inner) return normalizeResult(inner);
+    if (inner) {
+      const result = normalizeResult(inner);
+      debugLog("PARSE", `claude-json → ${result.tool_calls ? "tool_calls" : "content"}`, { toolCalls: result.tool_calls?.length ?? 0 });
+      return result;
+    }
     // Claude result is plain text
+    debugLog("PARSE", "claude-json → plain text", { len: claudeResult.length });
     return { content: claudeResult };
   }
 
   // Try direct JSON parse (for non-Claude outputs)
   const parsed = tryParseJson(trimmed);
-  if (parsed) return normalizeResult(parsed);
+  if (parsed) {
+    const result = normalizeResult(parsed);
+    debugLog("PARSE", `direct-json → ${result.tool_calls ? "tool_calls" : "content"}`, { toolCalls: result.tool_calls?.length ?? 0 });
+    return result;
+  }
 
   // Try extracting JSON from markdown code blocks: ```json ... ```
   const codeBlock = tryExtractCodeBlock(trimmed);
   if (codeBlock) {
     const inner = tryParseJson(codeBlock);
-    if (inner) return normalizeResult(inner);
+    if (inner) {
+      const result = normalizeResult(inner);
+      debugLog("PARSE", `code-block → ${result.tool_calls ? "tool_calls" : "content"}`, { toolCalls: result.tool_calls?.length ?? 0 });
+      return result;
+    }
   }
 
   // Try finding a JSON object anywhere in the text
   const embedded = tryExtractEmbeddedJson(trimmed);
   if (embedded) {
     const inner = tryParseJson(embedded);
-    if (inner) return normalizeResult(inner);
+    if (inner) {
+      const result = normalizeResult(inner);
+      debugLog("PARSE", `embedded-json → ${result.tool_calls ? "tool_calls" : "content"}`, { toolCalls: result.tool_calls?.length ?? 0 });
+      return result;
+    }
   }
 
   // Fallback: treat entire text as content
+  debugLog("PARSE", "no JSON found → raw content", { len: trimmed.length, preview });
   return { content: trimmed || null };
 }
 
@@ -167,11 +209,17 @@ function normalizeResult(obj: Record<string, unknown>): CliToolResult {
           : JSON.stringify(tc.arguments ?? {}),
       },
     }));
-    return { content: null, tool_calls: toolCalls };
+    // If the model also returned a content string alongside tool_calls, include it
+    const content = typeof obj.content === "string" ? obj.content : null;
+    return { content, tool_calls: toolCalls };
   }
 
-  // Check for content field
+  // Check for content field — but rescue embedded tool_calls JSON from inside content strings.
+  // Models sometimes wrap tool calls inside a content string:
+  //   {"content":"I'll write that file.\n{\"tool_calls\":[...]}"}
   if (typeof obj.content === "string") {
+    const rescued = tryRescueToolCallsFromContent(obj.content);
+    if (rescued) return rescued;
     return { content: obj.content };
   }
 
@@ -179,6 +227,41 @@ function normalizeResult(obj: Record<string, unknown>): CliToolResult {
   return { content: JSON.stringify(obj) };
 }
 
+/**
+ * Rescue tool_calls embedded inside a content string.
+ * Handles cases where the model wraps tool calls in a content field:
+ *   {"content":"Some text\n{\"tool_calls\":[...]}"}
+ *   {"content":"{\"tool_calls\":[{\"name\":\"write\",...}]}"}
+ */
+function tryRescueToolCallsFromContent(content: string): CliToolResult | null {
+  // Only attempt rescue if content contains the tool_calls signature
+  if (!content.includes('"tool_calls"') && !content.includes("tool_calls")) return null;
+
+  // Try to find embedded JSON with tool_calls
+  const embedded = tryExtractEmbeddedJson(content);
+  if (!embedded) return null;
+
+  const parsed = tryParseJson(embedded);
+  if (!parsed || !Array.isArray(parsed.tool_calls) || parsed.tool_calls.length === 0) return null;
+
+  // Extract the text content before the JSON (if any)
+  const jsonStart = content.indexOf(embedded);
+  const textBefore = jsonStart > 0 ? content.slice(0, jsonStart).trim() : null;
+
+  const toolCalls: ToolCall[] = parsed.tool_calls.map((tc: Record<string, unknown>) => ({
+    id: generateCallId(),
+    type: "function" as const,
+    function: {
+      name: String(tc.name ?? ""),
+      arguments: typeof tc.arguments === "string"
+        ? tc.arguments
+        : JSON.stringify(tc.arguments ?? {}),
+    },
+  }));
+
+  return { content: textBefore || null, tool_calls: toolCalls };
+}
+
 function tryParseJson(text: string): Record<string, unknown> | null {
   try {
     const obj = JSON.parse(text);

package/test/config.test.ts

@@ -38,7 +38,7 @@ describe("config.ts exports", () => {
     expect(DEFAULT_PROXY_TIMEOUT_MS).toBe(300_000);
     expect(DEFAULT_CLI_TIMEOUT_MS).toBe(120_000);
     expect(TIMEOUT_GRACE_MS).toBe(5_000);
-    expect(MAX_EFFECTIVE_TIMEOUT_MS).toBe(900_000);
+    expect(MAX_EFFECTIVE_TIMEOUT_MS).toBe(580_000); // under gateway's 600s
     expect(SESSION_TTL_MS).toBe(30 * 60 * 1000);
     expect(CLEANUP_INTERVAL_MS).toBe(5 * 60 * 1000);
     expect(SESSION_KILL_GRACE_MS).toBe(5_000);
@@ -61,8 +61,8 @@ describe("config.ts exports", () => {
   });
 
   it("exports per-model timeouts for all major models", () => {
-    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-opus-4-6"]).toBe(420_000);
-    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-sonnet-4-6"]).toBe(420_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-opus-4-6"]).toBe(360_000);
+    expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-sonnet-4-6"]).toBe(300_000);
     expect(DEFAULT_MODEL_TIMEOUTS["cli-claude/claude-haiku-4-5"]).toBe(120_000);
     expect(DEFAULT_MODEL_TIMEOUTS["cli-gemini/gemini-2.5-pro"]).toBe(300_000);
     expect(DEFAULT_MODEL_TIMEOUTS["cli-gemini/gemini-2.5-flash"]).toBe(180_000);

package/test/session-manager.test.ts

@@ -63,8 +63,10 @@ vi.mock("../src/workdir.js", () => ({
 }));
 
 // Mock config module — provide all constants needed by session-manager.ts and cli-runner.ts
-vi.mock("../src/config.js", async () => {
+vi.mock("../src/config.js", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../src/config.js")>();
   return {
+    ...actual,
     SESSION_TTL_MS: 30 * 60 * 1000,
     CLEANUP_INTERVAL_MS: 5 * 60 * 1000,
     SESSION_KILL_GRACE_MS: 5_000,