codehost 0.20.0 → 0.20.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.20.2](https://github.com/snomiao/codehost/compare/v0.20.1...v0.20.2) (2026-06-11)
+
+
+### Performance Improvements
+
+* **tunnel:** 64KB frames, gzip passthrough, immutable-asset SW cache, event-driven backpressure; ICE path badge ([da3647c](https://github.com/snomiao/codehost/commit/da3647c96ac1e323237e4743e7f0e4b1a83f741d))
+
+## [0.20.1](https://github.com/snomiao/codehost/compare/v0.20.0...v0.20.1) (2026-06-11)
+
+
+### Bug Fixes
+
+* **signaling:** tame the room-DO request storm; live agent titles on the sidepanel ([d39dceb](https://github.com/snomiao/codehost/commit/d39dceb2c7e3cd47dcb17f099aa8e0d37d3a7e13))
+
 # [0.20.0](https://github.com/snomiao/codehost/compare/v0.19.0...v0.20.0) (2026-06-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "type": "module",
   "repository": {
     "type": "git",

package/src/cli/commands/serve.ts

@@ -146,16 +146,26 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
     // so the advertised list and the provisioned paths agree.
     const layout = readCodehostConfig(dir).workspace || DEFAULT_LAYOUT;
     const plugins = [agentYesPlugin()].filter((p) => p != null);
+    // buildMeta runs every AGENTS_META_POLL_MS so live agent titles propagate
+    // (the room only sees a push when something changed). The filesystem walk
+    // for checkouts is the expensive part — memoize it; registered workspaces
+    // and agents are cheap reads and stay fresh on every call.
+    const WORKSPACE_WALK_TTL_MS = 30_000;
+    let wsWalk: { at: number; list: ReturnType<typeof enumerateWorkspaces> } | null = null;
     const buildMeta = (): PeerMeta => {
       // Layout-enumerated checkouts plus directories other `codehost dev` runs
       // registered with this host daemon (git-identified best-effort).
-      const workspaces = enumerateWorkspaces(dir, layout);
-      // The config dir itself is editable from the site (rendered as ⚙, opens
-      // in the editor) — advertised so its /host/<host>/<path> link resolves.
-      const configDir = join(dir, ".codehost");
-      if (existsSync(configDir)) {
-        workspaces.push({ path: toPosixPath(configDir), config: true });
+      if (!wsWalk || Date.now() - wsWalk.at > WORKSPACE_WALK_TTL_MS) {
+        const list = enumerateWorkspaces(dir, layout);
+        // The config dir itself is editable from the site (rendered as ⚙, opens
+        // in the editor) — advertised so its /host/<host>/<path> link resolves.
+        const configDir = join(dir, ".codehost");
+        if (existsSync(configDir)) {
+          list.push({ path: toPosixPath(configDir), config: true });
+        }
+        wsWalk = { at: Date.now(), list };
       }
+      const workspaces = [...wsWalk.list];
       for (const w of readRegisteredWorkspaces()) {
         const path = toPosixPath(w.path);
         if (workspaces.some((x) => x.path === path)) continue;
@@ -193,6 +203,9 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
       signal: argv.signal,
       meta: buildMeta(),
       refreshMeta: buildMeta,
+      // Fast poll so agents' self-set titles go live on the site sidepanel;
+      // per tick it's pid-liveness checks + log-tail stat()s (see liveTitle).
+      metaRefreshMs: 3_000,
       watchFiles: [workspacesFile()],
       plugins,
       label: `serving workspace root ${dir}`,

package/src/cli/plugins/agent-yes.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import { mkdtempSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { agentYesPlugin, readAgents } from "./agent-yes";
+import { agentYesPlugin, liveTitle, readAgents } from "./agent-yes";
 import { routePlugins, withPluginMeta } from "./types";
 
 function makeAyDir(lines: object[]): string {
@@ -34,6 +34,42 @@ describe("readAgents", () => {
   test("missing registry -> empty", () => {
     expect(readAgents(mkdtempSync(join(tmpdir(), "codehost-ay-empty-")))).toEqual([]);
   });
+
+  test("live OSC title from the log tail beats the launch prompt", () => {
+    const dir = mkdtempSync(join(tmpdir(), "codehost-ay-title-"));
+    const log = join(dir, "agent.raw.log");
+    writeFileSync(log, "boot\x1b]2;first title\x07work work\x1b]0;renamed by agent\x07tail");
+    writeFileSync(
+      join(dir, "pids.jsonl"),
+      JSON.stringify({
+        pid: process.pid,
+        cli: "claude",
+        prompt: "the launch prompt",
+        cwd: "/tmp/x",
+        log_file: log,
+        status: "active",
+      }) + "\n",
+    );
+    expect(readAgents(dir)[0].title).toBe("renamed by agent");
+  });
+});
+
+describe("liveTitle", () => {
+  test("returns the LAST OSC 0/2 title, cached by (size, mtime)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "codehost-ay-osc-"));
+    const log = join(dir, "x.log");
+    writeFileSync(log, "\x1b]0;one\x07...\x1b]2;two\x1b\\rest");
+    expect(liveTitle(log)).toBe("two");
+    expect(liveTitle(log)).toBe("two"); // cache hit path
+  });
+
+  test("missing file / no title -> null", () => {
+    expect(liveTitle("/nonexistent/x.log")).toBeNull();
+    const dir = mkdtempSync(join(tmpdir(), "codehost-ay-osc2-"));
+    const log = join(dir, "plain.log");
+    writeFileSync(log, "no escapes here");
+    expect(liveTitle(log)).toBeNull();
+  });
 });
 
 describe("plugin routing + meta", () => {

package/src/cli/plugins/agent-yes.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { closeSync, existsSync, fstatSync, openSync, readFileSync, readSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { toPosixPath } from "../../shared/repo";
@@ -22,10 +22,47 @@ interface AyRecord {
   cli?: string;
   prompt?: string | null;
   cwd?: string;
+  log_file?: string | null;
   status?: "active" | "idle" | "exited";
   started_at?: number;
 }
 
+// Agents retitle their terminal by writing OSC 0/2 (\x1b]2;name\x07) into the
+// PTY stream agent-yes logs; the most recent one is the live title (same trick
+// `ay serve` uses for /api/ls). Read straight from the log tail so it works
+// even when ay serve is down. Cached per (size, mtime): only logs that grew
+// since the last refresh are re-read, so a frequent meta poll stays cheap.
+const TITLE_TAIL_BYTES = 65536;
+const titleCache = new Map<string, { size: number; mtimeMs: number; title: string | null }>();
+
+export function liveTitle(logFile: string | null | undefined): string | null {
+  if (!logFile) return null;
+  try {
+    const fd = openSync(logFile, "r");
+    try {
+      const { size, mtimeMs } = fstatSync(fd);
+      const hit = titleCache.get(logFile);
+      if (hit && hit.size === size && hit.mtimeMs === mtimeMs) return hit.title;
+      const len = Math.min(size, TITLE_TAIL_BYTES);
+      const buf = Buffer.allocUnsafe(len);
+      const bytesRead = readSync(fd, buf, 0, len, size - len);
+      const text = buf.toString("utf-8", 0, bytesRead);
+      // eslint-disable-next-line no-control-regex
+      const oscTitleRe = /\x1b\][02];([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
+      let title: string | null = null;
+      for (let m: RegExpExecArray | null; (m = oscTitleRe.exec(text)); ) {
+        if (m[1].trim()) title = m[1].trim();
+      }
+      titleCache.set(logFile, { size, mtimeMs, title });
+      return title;
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+
 /** agent-yes's global registry: JSONL, last line per pid wins. */
 export function readAgents(dir: string = AY_DIR): AgentInfo[] {
   let raw: string;
@@ -48,10 +85,12 @@ export function readAgents(dir: string = AY_DIR): AgentInfo[] {
   for (const rec of [...byPid.values()].sort((a, b) => (b.started_at ?? 0) - (a.started_at ?? 0))) {
     if (out.length >= MAX_AGENTS) break;
     if (rec.status === "exited" || !alive(rec.pid)) continue;
+    // Live self-set title from the PTY log beats the static launch prompt.
+    const title = liveTitle(rec.log_file) ?? rec.prompt ?? null;
     out.push({
       pid: rec.pid,
       tool: rec.cli || "agent",
-      ...(rec.prompt ? { title: rec.prompt.slice(0, 120) } : {}),
+      ...(title ? { title: title.slice(0, 120) } : {}),
       cwd: toPosixPath(rec.cwd ?? ""),
       state: rec.status === "active" ? "active" : "idle",
       ...(rec.started_at ? { startedAt: rec.started_at } : {}),

package/src/cli/run-server.ts

@@ -31,10 +31,14 @@ export interface RunServerOptions {
   /** Enables `/__codehost/provision` on the tunnel (serve only — runs the home's
    *  setup.sh). Omitted by `expose`, which has no home/workspace. */
   provision?: ProvisionDeps;
-  /** Recompute the advertised meta (e.g. re-enumerate workspaces). Polled on a
-   *  slow interval and right after each provision; pushed to the room only when
+  /** Recompute the advertised meta (e.g. re-enumerate workspaces). Polled on
+   *  an interval and right after each provision; pushed to the room only when
    *  it actually changed. */
   refreshMeta?: () => PeerMeta;
+  /** Meta poll cadence (default META_REFRESH_MS). `serve` polls fast so live
+   *  agent titles propagate — refreshMeta must then be cheap per call. The
+   *  room only sees a message when the meta actually changed. */
+  metaRefreshMs?: number;
   /** Daemon plugins: tunneled routes under /__codehost/<name>/ (their meta
    *  contributions are the caller's job, inside `meta`/`refreshMeta`). */
   plugins?: DaemonPlugin[];
@@ -113,16 +117,24 @@ export async function runServer(opts: RunServerOptions): Promise<never> {
 
   client.connect();
   if (opts.refreshMeta) {
-    setInterval(refreshMeta, META_REFRESH_MS);
-    // Instant re-advertise when a watched file changes (debounced — editors
-    // and fs.watch both fire in bursts).
+    setInterval(refreshMeta, opts.metaRefreshMs ?? META_REFRESH_MS);
+    // Near-instant re-advertise when a watched file changes. Throttled, not
+    // debounced: fs.watch fires in bursts, but a file that changes CONSTANTLY
+    // (a busy registry) would keep resetting a debounce forever — a trailing
+    // throttle guarantees a refresh at most/at least every 300ms.
     let pending: ReturnType<typeof setTimeout> | null = null;
+    const requestRefresh = () => {
+      if (pending) return;
+      pending = setTimeout(() => {
+        pending = null;
+        refreshMeta();
+      }, 300);
+    };
     for (const file of opts.watchFiles ?? []) {
       try {
         watch(dirname(file), (_event, filename) => {
           if (filename && filename !== basename(file)) return;
-          if (pending) clearTimeout(pending);
-          pending = setTimeout(refreshMeta, 300);
+          requestRefresh();
         });
       } catch {
         // missing dir / unsupported platform — the interval still covers it

package/src/cli/tunnel.ts

@@ -13,6 +13,13 @@ import {
 
 const textDecoder = new TextDecoder();
 
+// Send-queue water marks. HIGH bounds how much data can sit ahead of an
+// interactive message on the (single, ordered) channel — at 20 Mbps, 4 MB is
+// already ~1.6 s of head-of-line latency, so resist raising it; LOW is where
+// the bufferedAmountLow event resumes a paused sender.
+const HIGH_WATER = 4 * 1024 * 1024;
+const LOW_WATER = 1 * 1024 * 1024;
+
 // Hop-by-hop headers that must not be forwarded across the tunnel.
 const HOP_BY_HOP = new Set([
   "connection",
@@ -72,6 +79,12 @@ export class Tunnel {
   ) {
     this.origin = `http://127.0.0.1:${vscodePort}`;
     this.wsOrigin = `ws://127.0.0.1:${vscodePort}`;
+    try {
+      this.channel.setBufferedAmountLowThreshold(LOW_WATER);
+      this.channel.onBufferedAmountLow(() => this.drainWaiter?.());
+    } catch {
+      // older node-datachannel: the poll in waitForDrain still covers it
+    }
     this.channel.onMessage((msg) => {
       if (typeof msg === "string") return; // all frames are binary
       const buf = msg as Buffer;
@@ -148,6 +161,14 @@ export class Tunnel {
     const hasBody = method !== "GET" && method !== "HEAD" && stream.body.length > 0;
     const body = hasBody ? concat(stream.body) : undefined;
 
+    // A client that can inflate (TunnelClient sends this marker) gets the
+    // upstream's gzip bytes passed through UNTOUCHED — 3-4x fewer bytes over
+    // the channel for VS Code's JS/CSS. gzip only: the browser inflates with
+    // DecompressionStream, which has no brotli.
+    const wantsGzip = reqHeaders.get("x-codehost-accept-gzip") === "1";
+    reqHeaders.delete("x-codehost-accept-gzip");
+    if (wantsGzip) reqHeaders.set("accept-encoding", "gzip");
+
     try {
       const local = this.onLocal?.({ method, path, headers: reqHeaders, body });
       const res = local
@@ -157,6 +178,8 @@ export class Tunnel {
             headers: reqHeaders,
             body: body as BodyInit | undefined,
             redirect: "manual",
+            // Bun extension: don't auto-inflate — keep the wire bytes compressed.
+            ...(wantsGzip ? ({ decompress: false } as RequestInit) : {}),
           });
 
       const resHeaders: Record<string, string> = {};
@@ -240,15 +263,26 @@ export class Tunnel {
     return p;
   }
 
+  // Fires from onBufferedAmountLow so a paused sender resumes the moment the
+  // queue drains past LOW_WATER instead of on the next poll tick.
+  private drainWaiter: (() => void) | null = null;
+
   private waitForDrain(): Promise<void> {
-    const HIGH = 8 * 1024 * 1024; // 8 MB
-    if (!this.channel.isOpen() || this.channel.bufferedAmount() < HIGH) return Promise.resolve();
+    if (!this.channel.isOpen() || this.channel.bufferedAmount() < HIGH_WATER) return Promise.resolve();
     return new Promise((resolve) => {
-      const tick = () => {
-        if (!this.channel.isOpen() || this.channel.bufferedAmount() < HIGH) resolve();
-        else setTimeout(tick, 10);
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        clearInterval(timer);
+        this.drainWaiter = null;
+        resolve();
       };
-      tick();
+      this.drainWaiter = finish;
+      // Safety poll in case the low event raced or isn't available.
+      const timer = setInterval(() => {
+        if (!this.channel.isOpen() || this.channel.bufferedAmount() < HIGH_WATER) finish();
+      }, 100);
     });
   }
 

package/src/shared/protocol.ts

@@ -31,12 +31,15 @@ export enum Op {
   WsCont = 13,
 }
 
-// WebRTC data-channel messages must stay small to be portable: 16 KiB is the
-// largest size every WebRTC stack (libdatachannel, Chrome, Firefox) reliably
-// accepts. A frame is [op:1][streamId:4][payload], so the payload budget is
-// 16 KiB minus the 5-byte header.
+// Frame size vs JS overhead: every frame costs a promise hop + two copies on
+// its way through the tunnel, so bigger frames = faster bulk transfer. Both
+// stacks we pair (Chrome/Firefox <-> libdatachannel) negotiate an SCTP
+// max-message-size of 256 KiB, so 64 KiB rides well inside every negotiated
+// limit while cutting per-MB frame count 4x vs the old 16 KiB. Receivers
+// accept any frame size (decodeFrame is length-agnostic), so mixed old/new
+// peers interoperate. A frame is [op:1][streamId:4][payload].
 export const FRAME_HEADER = 5;
-export const MAX_FRAME = 16 * 1024;
+export const MAX_FRAME = 64 * 1024;
 /** Max payload bytes per frame; larger bodies/messages are split across frames. */
 export const MAX_CHUNK = MAX_FRAME - FRAME_HEADER;
 

package/src/shared/signaling-client.ts

@@ -34,8 +34,10 @@ export interface CloseInfo {
  *  connection that completes the handshake then drops within seconds (a
  *  middlebox that accepts the WebSocket upgrade but kills the socket, seen on
  *  some field networks) must keep backing off — otherwise every reset-to-1s
- *  open/close cycle becomes a sub-second reconnect storm. */
-const STABLE_MS = 10_000;
+ *  open/close cycle becomes a sub-second reconnect storm. A server that drops
+ *  sockets every few tens of seconds (room DO redeploys, sweep evictions) must
+ *  also keep backing off, so this sits above any such churn period. */
+const STABLE_MS = 60_000;
 
 /** Abort a connect attempt that hasn't opened by this deadline. Observed in the
  *  field (Chrome, page-load burst): a socket can sit in CONNECTING for minutes
@@ -43,6 +45,20 @@ const STABLE_MS = 10_000;
  *  freshly-created socket to the same room opens instantly. */
 const CONNECT_TIMEOUT_MS = 10_000;
 
+/** Reconnect backoff bounds. Every signaling round-trip (WS upgrade, hello,
+ *  ping) is a billable request on the room Durable Object, so idle/broken
+ *  clients must converge to a slow cadence: cap at 2 min, with ±25% jitter so
+ *  a fleet of daemons dropped by one server restart doesn't thundering-herd. */
+const RECONNECT_MIN_MS = 1_000;
+const RECONNECT_MAX_MS = 120_000;
+
+/** Heartbeat cadence. Paired with the room's STALE_MS (65s): the sweep
+ *  tolerates ~2 missed beats. Each ping is a billable DO request — at 25s a
+ *  day-long connection costs ~3.5k requests, vs ~8.6k at the old 10s. Hidden
+ *  tabs survive too: Chrome's intensive throttling clamps timers to 1/min,
+ *  still inside the 65s window. */
+const HEARTBEAT_MS = 25_000;
+
 /**
  * Thin WebSocket client for the signaling room. Runs unchanged in the browser
  * and in Bun (both expose a global `WebSocket`). Auto-reconnects with backoff
@@ -52,8 +68,10 @@ export class SignalingClient {
   readonly peerId: string;
   private ws: WebSocket | null = null;
   private closed = false;
-  private reconnectDelay = 1000;
+  private reconnectDelay = RECONNECT_MIN_MS;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  /** True while a hidden tab sits out reconnection; onWake resumes it. */
+  private dormant = false;
   private heartbeat: ReturnType<typeof setInterval> | null = null;
   /** Fires STABLE_MS after a socket opens; only then is the backoff reset. */
   private stableTimer: ReturnType<typeof setTimeout> | null = null;
@@ -90,13 +108,24 @@ export class SignalingClient {
       }
       return;
     }
-    // Closed and waiting out the (throttled) backoff: skip the wait.
-    if (this.reconnectTimer != null) {
+    // Dormant (hidden tab sat out reconnection) or waiting out a throttled
+    // backoff: reconnect now.
+    if (this.dormant || this.reconnectTimer != null) {
+      this.dormant = false;
       this.clearReconnectTimer();
       this.open();
     }
   };
 
+  /** A hidden tab doesn't reconnect at all — abandoned tabs used to churn
+   *  evict/reconnect cycles against the room DO all night. Existing WebRTC
+   *  tunnels keep working without signaling; on visibility/focus/online the
+   *  wake handler reconnects within milliseconds. */
+  private hidden(): boolean {
+    const doc = (globalThis as { document?: { visibilityState?: string } }).document;
+    return doc?.visibilityState === "hidden";
+  }
+
   private attachWakeListeners(): void {
     const doc = (globalThis as { document?: EventTarget }).document;
     doc?.addEventListener("visibilitychange", this.onWake);
@@ -143,7 +172,7 @@ export class SignalingClient {
       // its backoff keeps growing instead of hammering at 1s.
       this.clearStableTimer();
       this.stableTimer = setTimeout(() => {
-        this.reconnectDelay = 1000;
+        this.reconnectDelay = RECONNECT_MIN_MS;
       }, STABLE_MS);
       const hello: ClientMessage = {
         type: "hello",
@@ -186,9 +215,8 @@ export class SignalingClient {
     };
   }
 
-  // Heartbeat keeps the room's liveness sweep from evicting us. At 10s, the DO
-  // (STALE_MS 35s) tolerates ~3 missed beats before treating us as gone — fast
-  // enough that a crashed peer stops showing as a phantom server within ~1 sweep.
+  // Heartbeat keeps the room's liveness sweep from evicting us — see
+  // HEARTBEAT_MS for the cadence/cost trade-off.
   private startHeartbeat(): void {
     this.stopHeartbeat();
     this.heartbeat = setInterval(() => {
@@ -197,7 +225,7 @@ export class SignalingClient {
       } catch {
         // socket gone; onclose will reconnect
       }
-    }, 10000);
+    }, HEARTBEAT_MS);
   }
 
   private stopHeartbeat(): void {
@@ -215,12 +243,23 @@ export class SignalingClient {
   }
 
   private scheduleReconnect(): void {
-    const delay = this.reconnectDelay;
-    this.reconnectDelay = Math.min(delay * 2, 15000);
+    if (this.hidden()) {
+      this.dormant = true;
+      return;
+    }
+    // ±25% jitter so a fleet dropped together doesn't reconnect together.
+    const delay = Math.round(this.reconnectDelay * (0.75 + Math.random() * 0.5));
+    this.reconnectDelay = Math.min(this.reconnectDelay * 2, RECONNECT_MAX_MS);
     this.clearReconnectTimer();
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
-      if (!this.closed) this.open();
+      if (this.closed) return;
+      if (this.hidden()) {
+        // Went hidden while waiting — sit out until the wake handler fires.
+        this.dormant = true;
+        return;
+      }
+      this.open();
     }, delay);
   }
 
@@ -248,6 +287,7 @@ export class SignalingClient {
 
   close(): void {
     this.closed = true;
+    this.dormant = false;
     this.detachWakeListeners();
     this.clearReconnectTimer();
     this.stopHeartbeat();

package/src/web/discovery.tsx

@@ -193,6 +193,9 @@ export function Discovery() {
   // client carries the peer's signaling and it's the token Share/history record.
   const [activePeerId, setActivePeerId] = useState<string | null>(null);
   const [connState, setConnState] = useState<ConnState>("idle");
+  // ICE path of the live session ("lan" | "p2p"); null when unknown or when
+  // this tab rides another tab's connection via the broker.
+  const [connPath, setConnPath] = useState<"lan" | "p2p" | null>(null);
   const [iframeSrc, setIframeSrc] = useState<string | null>(null);
   // Streamed setup.sh output shown while connState === "provisioning".
   const [provisionLog, setProvisionLog] = useState("");
@@ -455,6 +458,22 @@ export function Discovery() {
 
       await connBroker.connect(server.peerId, establish);
 
+      // Show which ICE path got nominated (owner tab only — a proxied tab has
+      // no RTCPeerConnection of its own). ICE may re-nominate just after the
+      // channel opens, so sample again shortly.
+      setConnPath(null);
+      // (assertion: TS narrows the ref to null from the reset above and can't
+      // see that `establish` re-assigned it)
+      const rtcForPath = rtcRef.current as RtcClient | null;
+      if (rtcForPath) {
+        const sample = () =>
+          void rtcForPath.selectedPath().then((p) => {
+            if (rtcRef.current === rtcForPath && p) setConnPath(p);
+          });
+        sample();
+        setTimeout(sample, 3000);
+      }
+
       // For a repo deep link, ask the daemon to provision (run .codehost/setup.sh
       // and hand back the authoritative workspace path) before opening. Streams
       // the log under the "provisioning" state. Daemons without the route (older
@@ -624,6 +643,7 @@ export function Discovery() {
     rtcRef.current = null;
     if (activePeerRef.current) connBroker.disconnect(activePeerRef.current);
     setIframeSrc(null);
+    setConnPath(null);
     setActivePeerId(null);
     activePeerRef.current = null;
     activeRoomRef.current = null;
@@ -795,6 +815,18 @@ export function Discovery() {
                 activeServer?.meta?.name ??
                 activePeerId?.slice(0, 8)}
             </span>
+            {connPath && (
+              <span
+                style={styles.dim}
+                title={
+                  connPath === "lan"
+                    ? "direct LAN path — both ends on the same network"
+                    : "direct peer-to-peer path (NAT traversed)"
+                }
+              >
+                {connPath === "lan" ? "⚡LAN" : "🌐p2p"}
+              </span>
+            )}
             <span style={{ flex: 1 }} />
             <button
               style={styles.shareBtn}
@@ -1000,6 +1032,7 @@ export function Discovery() {
                       >
                         <span style={{ color: a.state === "active" ? "#4ec9b0" : "#777" }}>●</span> {a.tool}{" "}
                         {a.pid}
+                        {a.title && <span style={styles.agentTitle}>{a.title}</span>}
                       </a>
                     ))}
                   </div>
@@ -1118,6 +1151,13 @@ const styles: Record<string, React.CSSProperties> = {
   agentChip: {
     fontFamily: "monospace", fontSize: 11.5, padding: "2px 8px", borderRadius: 999,
     border: "1px solid #3d3d3d", color: "#9aa4af", textDecoration: "none", cursor: "pointer",
+    display: "inline-flex", alignItems: "baseline", gap: 4, maxWidth: 360,
+  },
+  // Live self-set agent title (daemon re-reads it from the PTY log and pushes
+  // a meta update, so this re-renders as the agent renames itself).
+  agentTitle: {
+    color: "#6e7681", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap",
+    minWidth: 0, flex: "0 1 auto",
   },
   card: { display: "flex", alignItems: "center", gap: 12, background: "#252525", border: "1px solid #3d3d3d", borderRadius: 8, padding: "12px 14px" },
   cardMain: { flex: 1, minWidth: 0 },

package/src/web/room-client.ts

@@ -25,12 +25,19 @@ export interface RoomOptions {
   onStatus?: (open: boolean) => void;
 }
 
+/** After a failed dial, refuse redials to that peer for this long. Pollers
+ *  (the agent-yes console asks every host for /api/ls every ~3s) would
+ *  otherwise spin up a fresh RTCPeerConnection per poll, and every ICE
+ *  candidate of every attempt is a billable signaling-DO request. */
+const DIAL_FAIL_COOLDOWN_MS = 10_000;
+
 export class CodehostRoom {
   /** Server peers currently in the room (viewers filtered out). */
   peers: PeerInfo[] = [];
   private signaling: SignalingClient;
   private rtcs = new Map<string, RtcClient>();
   private tunnels = new Map<string, Promise<TunnelClient>>();
+  private dialFailedAt = new Map<string, number>();
   private closed = false;
 
   constructor(opts: RoomOptions) {
@@ -65,6 +72,10 @@ export class CodehostRoom {
   private dial(peerId: string): Promise<TunnelClient> {
     const existing = this.tunnels.get(peerId);
     if (existing) return existing;
+    const failedAt = this.dialFailedAt.get(peerId);
+    if (failedAt != null && Date.now() - failedAt < DIAL_FAIL_COOLDOWN_MS) {
+      return Promise.reject(new Error("dial failed recently; cooling down"));
+    }
     const drop = () => {
       this.tunnels.delete(peerId);
       this.rtcs.get(peerId)?.close();
@@ -79,6 +90,7 @@ export class CodehostRoom {
         sendSignal: (data: RtcSignal) => this.signaling.sendSignal(peerId, data),
         onOpen: (channel) => {
           clearTimeout(timer);
+          this.dialFailedAt.delete(peerId);
           resolve(new TunnelClient(channel));
         },
         onClose: drop,
@@ -94,7 +106,10 @@ export class CodehostRoom {
       });
     });
     this.tunnels.set(peerId, dialing);
-    dialing.catch(() => this.tunnels.delete(peerId));
+    dialing.catch(() => {
+      this.dialFailedAt.set(peerId, Date.now());
+      this.tunnels.delete(peerId);
+    });
     return dialing;
   }
 

package/src/web/rtc-client.ts

@@ -69,6 +69,42 @@ export class RtcClient {
     return this.channel;
   }
 
+  /**
+   * Which ICE path the nominated candidate pair uses: "lan" when both ends
+   * are host candidates (same network — traffic never leaves it), "p2p" for a
+   * NAT-traversed direct path, null while undetermined. Surfaced in the UI so
+   * "it feels slow" reports come with the path attached.
+   */
+  async selectedPath(): Promise<"lan" | "p2p" | null> {
+    try {
+      const stats = await this.pc.getStats();
+      let pairId: string | null = null;
+      stats.forEach((s) => {
+        if (s.type === "transport" && s.selectedCandidatePairId) pairId = s.selectedCandidatePairId;
+      });
+      let pair: RTCIceCandidatePairStats | null = null;
+      stats.forEach((s) => {
+        if (pairId ? s.id === pairId : s.type === "candidate-pair" && s.state === "succeeded" && s.nominated) {
+          pair = s as RTCIceCandidatePairStats;
+        }
+      });
+      if (!pair) return null;
+      const { localCandidateId, remoteCandidateId } = pair as RTCIceCandidatePairStats;
+      let lan = true;
+      let found = 0;
+      stats.forEach((s) => {
+        if (s.id === localCandidateId || s.id === remoteCandidateId) {
+          found++;
+          if ((s as { candidateType?: string }).candidateType !== "host") lan = false;
+        }
+      });
+      if (found < 2) return null;
+      return lan ? "lan" : "p2p";
+    } catch {
+      return null;
+    }
+  }
+
   close(): void {
     try {
       this.channel?.close();

package/src/web/sw.ts

@@ -10,6 +10,12 @@ const sw = self as unknown as ServiceWorkerGlobalScope;
 
 const VS_PREFIX = /^\/vs\/([^/]+)(\/.*)?$/;
 const CDN_CACHE = "codehost-cdn-v1";
+const VS_STATIC_CACHE = "codehost-vs-static-v1";
+// VS Code's own immutable assets: /stable-<commit>/static/** is content-
+// addressed by the commit hash and identical across daemons, so it's cached
+// once per browser instead of crossing the WebRTC tunnel on every load. The
+// cache key strips the per-process /vs/<peerId> prefix.
+const VS_STATIC = /^\/(stable-[0-9a-f]{40})\/static\//;
 
 sw.addEventListener("install", () => sw.skipWaiting());
 sw.addEventListener("activate", (e) => e.waitUntil(sw.clients.claim()));
@@ -35,10 +41,39 @@ sw.addEventListener("fetch", (event: FetchEvent) => {
   const m = url.pathname.match(VS_PREFIX);
   if (!m) return; // let the network/Pages handle the discovery app itself
   const peerId = m[1];
+  const rest = (m[2] ?? "/") + url.search;
+
+  if (event.request.method === "GET" && !event.request.headers.has("range") && VS_STATIC.test(rest)) {
+    event.respondWith(cachedStatic(event.request, peerId, rest));
+    return;
+  }
 
   event.respondWith(proxyOverTunnel(event.request, peerId));
 });
 
+/** Cache-first for the immutable VS Code static assets; on a cache miss the
+ *  tunnel fills it, and assets of other (older) commits are evicted. */
+async function cachedStatic(request: Request, peerId: string, rest: string): Promise<Response> {
+  const key = `${sw.location.origin}/__codehost/vs-static${rest}`;
+  const cache = await caches.open(VS_STATIC_CACHE);
+  const hit = await cache.match(key);
+  if (hit) return hit;
+  const res = await proxyOverTunnel(request, peerId);
+  if (res.status === 200) {
+    void cache.put(key, res.clone()).catch(() => {});
+    void evictOtherCommits(cache, rest).catch(() => {});
+  }
+  return res;
+}
+
+async function evictOtherCommits(cache: Cache, rest: string): Promise<void> {
+  const commit = rest.match(VS_STATIC)?.[1];
+  if (!commit) return;
+  for (const req of await cache.keys()) {
+    if (!new URL(req.url).pathname.includes(`/${commit}/`)) void cache.delete(req);
+  }
+}
+
 /**
  * Fetch an allow-listed VS Code CDN asset through the signaling Worker's /cdn
  * route (which adds CORS), caching the result so each asset crosses to the

package/src/web/tunnel-client.ts

@@ -118,14 +118,31 @@ export class TunnelClient {
         },
       });
 
+      // Tell the daemon we can inflate: it then passes the upstream's gzip
+      // bytes through untouched (3-4x fewer bytes over the channel) and we
+      // decompress here, once, for every consumer.
+      const reqHeaders =
+        typeof DecompressionStream !== "undefined"
+          ? { ...headers, "x-codehost-accept-gzip": "1" }
+          : headers;
+
       this.https.set(streamId, {
         onHead: (h) => {
           head = h;
+          const resHeaders = new Headers(h.headers);
+          let bodyStream: ReadableStream<Uint8Array> = stream;
+          if (resHeaders.get("content-encoding") === "gzip") {
+            bodyStream = stream.pipeThrough(
+              new DecompressionStream("gzip") as unknown as ReadableWritablePair<Uint8Array, Uint8Array>,
+            );
+            resHeaders.delete("content-encoding");
+            resHeaders.delete("content-length");
+          }
           resolve(
-            new Response(stream, {
+            new Response(bodyStream, {
               status: h.status === 204 || h.status === 304 ? h.status : h.status,
               statusText: h.statusText,
-              headers: h.headers,
+              headers: resHeaders,
             }),
           );
         },
@@ -154,7 +171,7 @@ export class TunnelClient {
         },
       });
 
-      this.send(encodeJson(Op.HttpReq, streamId, { method, path, headers }));
+      this.send(encodeJson(Op.HttpReq, streamId, { method, path, headers: reqHeaders }));
       if (body && body.byteLength) {
         for (const part of chunk(body)) this.send(encodeFrame(Op.HttpReqBody, streamId, part));
       }

package/worker/room.ts

@@ -15,10 +15,14 @@ interface Attachment {
 }
 
 /** How often the room scans for dead sockets, and how long a socket may go
- *  silent before eviction. Clients heartbeat every ~10s; allow ~3 misses, so a
- *  crashed peer drops out within ~35-50s instead of lingering as a phantom. */
-const SWEEP_MS = 15_000;
-const STALE_MS = 35_000;
+ *  silent before eviction. Clients heartbeat every ~25s (HEARTBEAT_MS in
+ *  signaling-client.ts); allow ~2 misses, so a crashed peer drops out within
+ *  ~65-85s. Every sweep alarm and every ping is a billable DO request, so both
+ *  cadences are deliberately slow — a hidden Chrome tab's throttled timers
+ *  (1/min) must still beat STALE_MS, or background tabs churn evict/reconnect
+ *  cycles all day. */
+const SWEEP_MS = 20_000;
+const STALE_MS = 65_000;
 
 /**
  * One Durable Object instance per token-room. Holds the live WebSocket