agent-yes 1.205.0 → 1.206.0

package/ts/serve.ts

@@ -38,6 +38,7 @@ import {
 } from "./subcommands.ts";
 import { TYPING_BADGE } from "./badges.ts";
 import { isTerminalReply } from "./terminalReply.ts";
+import { parseStatusText } from "./statusText.ts";
 import { ensureNodeRuntime, liveEnv } from "./nodeRuntime.ts";
 import { acquireWebrtcHostLock, type ServeLockOwner } from "./serveLock.ts";
 import { type MailParty, recordInbox } from "./messageLog.ts";
@@ -58,7 +59,56 @@ import {
   resolveSpawnCwd,
 } from "./workspaceConfig.ts";
 
-const DEFAULT_PORT = 7432;
+const DEFAULT_PORT = 0;
+const PORTLESS_APP_NAME = "agent-yes";
+const PORTLESS_CHILD_ENV = "AGENT_YES_PORTLESS_CHILD";
+
+export function portlessConsoleUrl(token?: string): string {
+  return portlessConsoleUrlForOrigin(
+    process.env.PORTLESS_URL?.replace(/\/$/, "") || `https://${PORTLESS_APP_NAME}.localhost`,
+    token,
+  );
+}
+
+function portlessConsoleUrlForOrigin(origin: string, token?: string): string {
+  const fragment = token ? `/#k=${encodeURIComponent(token)}` : "/";
+  return `${origin}${fragment}`;
+}
+
+async function resolvedPortlessConsoleUrl(token?: string): Promise<string> {
+  if (process.env.PORTLESS_URL) return portlessConsoleUrl(token);
+  try {
+    const port = Number(
+      (await readFile(path.join(homedir(), ".portless", "proxy.port"), "utf-8")).trim(),
+    );
+    if (Number.isInteger(port) && port > 0)
+      return portlessConsoleUrlForOrigin(
+        `https://${PORTLESS_APP_NAME}.localhost${port === 443 ? "" : `:${port}`}`,
+        token,
+      );
+  } catch {
+    /* Portless has not created state yet. */
+  }
+  return portlessConsoleUrl(token);
+}
+
+async function runWithPortless(rest: string[]): Promise<number> {
+  const portless = Bun.which("portless");
+  if (!portless) {
+    process.stderr.write(
+      "ay serve: Portless is required for local HTTPS. Install it with: npm install -g portless\n",
+    );
+    return 1;
+  }
+  const script = process.argv[1];
+  const self =
+    script && /\.[cm]?[jt]s$/.test(script) ? [process.execPath, script] : [process.execPath];
+  const proc = Bun.spawn([portless, PORTLESS_APP_NAME, ...self, "serve", ...rest], {
+    stdio: ["inherit", "inherit", "inherit"],
+    env: { ...liveEnv(), [PORTLESS_CHILD_ENV]: "1" },
+  });
+  return (await proc.exited) ?? 1;
+}
 
 /**
  * Normalize a user-supplied GitHub-ish source into the standard
@@ -704,9 +754,28 @@ async function readDaemonServeArgs(mgr: DaemonManager): Promise<string[] | null>
   }
 }
 
-function portFromArgs(args: string[]): number {
+function portFromArgs(args: string[]): number | null {
   const m = /--port[=\s](\d+)/.exec(args.join(" "));
-  return m ? Number(m[1]) : DEFAULT_PORT;
+  return m ? Number(m[1]) : null;
+}
+
+function argsUsePortless(args: string[]): boolean {
+  const wantsHttp =
+    args.some((a) => a.startsWith("--http") || a.startsWith("--share")) ||
+    !args.some((a) => a.startsWith("--webrtc"));
+  return wantsHttp && portFromArgs(args) === null;
+}
+
+async function portlessAppPort(): Promise<number | null> {
+  try {
+    const routes = JSON.parse(
+      await readFile(path.join(homedir(), ".portless", "routes.json"), "utf-8"),
+    ) as { hostname?: string; port?: number }[];
+    const route = routes.find((r) => r.hostname === `${PORTLESS_APP_NAME}.localhost`);
+    return typeof route?.port === "number" ? route.port : null;
+  } catch {
+    return null;
+  }
 }
 
 async function warnStrayServeProcesses(): Promise<void> {
@@ -741,7 +810,8 @@ function explicitWebrtcUrl(args: string[]): string | undefined {
 // Ask the live daemon its version over the local HTTP API. null if it's not
 // listening (webrtc-only) or too old to expose /api/version — both of which we
 // treat as "outdated" so a re-install rolls it forward.
-async function fetchDaemonVersion(port: number, token: string): Promise<string | null> {
+async function fetchDaemonVersion(port: number | null, token: string): Promise<string | null> {
+  if (port === null) return null;
   try {
     const r = await fetch(`http://127.0.0.1:${port}/api/version`, {
       headers: { Authorization: `Bearer ${token}` },
@@ -889,7 +959,8 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
       // share link for a WebRTC bridge that isn't actually running. A bare re-run
       // passes no args, so effArgs === priorArgs and this stays a no-op as before.
       const sameConfig = JSON.stringify(effArgs) === JSON.stringify(priorArgs);
-      const runningVer = await fetchDaemonVersion(portFromArgs(effArgs), token);
+      const daemonPort = argsUsePortless(effArgs) ? await portlessAppPort() : portFromArgs(effArgs);
+      const runningVer = await fetchDaemonVersion(daemonPort, token);
       if (runningVer === current && sameConfig) {
         await ensureBootAutostart(mgr);
         process.stdout.write(`'${DAEMON_NAME}' already running v${current} (up to date)\n`);
@@ -982,7 +1053,8 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
     const code = await proc.exited;
     if (code === 0) {
       const onBoot = await ensureBootAutostart(mgr);
-      const port = portFromArgs(effArgs);
+      const port = argsUsePortless(effArgs) ? await portlessAppPort() : portFromArgs(effArgs);
+      const localUrl = argsUsePortless(effArgs) ? await resolvedPortlessConsoleUrl(token) : null;
       // Mirror cmdServe's mode resolution: webrtc-only daemons open no HTTP port.
       const httpish =
         effArgs.some((a) => a.startsWith("--http") || a.startsWith("--share")) ||
@@ -1020,8 +1092,12 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
         );
       process.stdout.write(`token: ${token}\n\n`);
       if (httpish) {
-        process.stdout.write(`  ay ls   ${token}@<host>:${port}\n`);
-        process.stdout.write(`  ay remote add <alias> http://${token}@<host>:${port}\n`);
+        if (argsUsePortless(effArgs)) {
+          process.stdout.write(`  web console: ${localUrl}\n`);
+        } else if (port !== null) {
+          process.stdout.write(`  ay ls   ${token}@<host>:${port}\n`);
+          process.stdout.write(`  ay remote add <alias> http://${token}@<host>:${port}\n`);
+        }
       }
       process.stdout.write(`  ay serve logs                # view server logs\n`);
       process.stdout.write(`  ay serve uninstall           # remove daemon\n`);
@@ -1054,7 +1130,9 @@ async function cmdServeStatus(args: string[]): Promise<number> {
   const daemonArgs = mgr ? await readDaemonServeArgs(mgr) : null;
   const installed = daemonArgs !== null;
   const a = daemonArgs ?? [];
-  const port = portFromArgs(a);
+  const local = argsUsePortless(a);
+  const port = local ? await portlessAppPort() : portFromArgs(a);
+  const localUrl = local ? await resolvedPortlessConsoleUrl(token ?? undefined) : null;
   // Mirror cmdServe/install mode resolution: webrtc when --webrtc/--share; http
   // when --http/--share OR no --webrtc at all (http is the implicit default).
   const webrtcish = a.some((x) => x.startsWith("--webrtc") || x.startsWith("--share"));
@@ -1076,6 +1154,7 @@ async function cmdServeStatus(args: string[]): Promise<number> {
           installed,
           mode,
           port: httpish ? port : null,
+          localUrl: httpish ? localUrl : null,
           reachable: runningVersion !== null,
           runningVersion,
           currentVersion: current,
@@ -1096,25 +1175,32 @@ async function cmdServeStatus(args: string[]): Promise<number> {
   w(`manager:      ${mgr ? mgr.id : "none — install pm2 or oxmgr to daemonize"}`);
   if (installed) {
     w(`installed:    yes (via ${mgr!.id})`);
-    w(`mode:         ${mode}${httpish ? `  (port ${port})` : ""}`);
+    w(`mode:         ${mode}${httpish ? (local ? `  (${localUrl})` : `  (port ${port})`) : ""}`);
     if (a.length) w(`args:         ${a.join(" ")}`);
   } else {
     w(`installed:    no — start a daemon with:  ay serve install [--share]`);
   }
   if (runningVersion !== null) {
     const tag = runningVersion === current ? "up to date" : `outdated (current v${current})`;
-    w(`http api:     reachable on 127.0.0.1:${port} — v${runningVersion} (${tag})`);
+    w(
+      `http api:     reachable ${local ? `via ${localUrl}` : `on 127.0.0.1:${port}`} — v${runningVersion} (${tag})`,
+    );
   } else if (mode === "webrtc") {
     w(`http api:     none (webrtc-only)`);
   } else {
-    w(`http api:     not reachable on 127.0.0.1:${port} (not running)`);
+    w(
+      `http api:     not reachable ${local ? `via ${localUrl}` : `on 127.0.0.1:${port}`} (not running)`,
+    );
   }
   w(`token:        ${token ?? "(none yet — created on first serve)"}`);
   if (shareLink) w(`share link:   ${shareLink}`);
   if (token && httpish) {
     w();
-    w(`connect:  ay ls   ${token}@<host>:${port}`);
-    w(`          ay remote add <alias> http://${token}@<host>:${port}`);
+    if (local) w(`console:  ${localUrl}`);
+    else if (port !== null) {
+      w(`connect:  ay ls   ${token}@<host>:${port}`);
+      w(`          ay remote add <alias> http://${token}@<host>:${port}`);
+    }
   }
   return 0;
 }
@@ -1138,11 +1224,13 @@ export async function cmdServe(rest: string[]): Promise<number> {
         `                    (stable link across restarts; delete the file to rotate).\n` +
         `  --share [URL]     Legacy alias for --http --webrtc\n\n` +
         `Options:\n` +
-        `  --port N          Port to listen on (default: ${DEFAULT_PORT})\n` +
+        `  --port N          Bypass Portless and listen on a fixed HTTP port\n` +
         `  --host HOST       Interface to bind (default: 127.0.0.1; use 0.0.0.0 to expose)\n` +
         `  --token TOKEN     Auth token (auto-generated and saved if omitted)\n` +
         `  -d, --daemon      Install these flags as a background daemon (pm2/oxmgr)\n` +
         `                    (same as: ay serve install <flags>)\n` +
+        `  --local           Explicitly use Portless (the default for HTTP mode)\n` +
+        `                    ${portlessConsoleUrl()}\n` +
         `  --allow-spawn     Deprecated no-op — the console can always spawn agents\n` +
         `  --tls-cert FILE   TLS certificate PEM\n` +
         `  --tls-key  FILE   TLS private key PEM\n\n` +
@@ -1152,8 +1240,8 @@ export async function cmdServe(rest: string[]): Promise<number> {
         `  ay serve uninstall  remove daemon\n` +
         `  ay serve logs       view daemon logs\n\n` +
         `Once running, connect from another machine:\n` +
-        `  ay ls   <token>@<host>:${DEFAULT_PORT}\n` +
-        `  ay remote add <alias> http://<token>@<host>:${DEFAULT_PORT}\n`,
+        `  ay ls   <token>@<host>:<port>\n` +
+        `  ay remote add <alias> http://<token>@<host>:<port>\n`,
     );
     return 0;
   }
@@ -1189,7 +1277,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
 
   const y = yargs(rest)
     .usage("Usage: ay serve [options]")
-    .option("port", { type: "number", default: DEFAULT_PORT, description: "Port to listen on" })
+    .option("port", { type: "number", description: "Bypass Portless and listen on a fixed port" })
     .option("host", {
       type: "string",
       default: "127.0.0.1",
@@ -1217,6 +1305,11 @@ export async function cmdServe(rest: string[]): Promise<number> {
       default: false,
       description: "Install as a background daemon (same as: ay serve install <flags>)",
     })
+    .option("local", {
+      type: "boolean",
+      default: false,
+      description: `Use Portless at ${portlessConsoleUrl()} (default for HTTP mode)`,
+    })
     .option("allow-spawn", {
       type: "boolean",
       default: false,
@@ -1225,7 +1318,8 @@ export async function cmdServe(rest: string[]): Promise<number> {
     .option("takeover", {
       type: "boolean",
       default: false,
-      description: "If another ay serve already hosts this home's WebRTC room, stop it and take the room",
+      description:
+        "If another ay serve already hosts this home's WebRTC room, stop it and take the room",
     })
     .help(false)
     .version(false)
@@ -1240,6 +1334,18 @@ export async function cmdServe(rest: string[]): Promise<number> {
     return cmdServeDaemon("install", fwd);
   }
 
+  const wantWebrtc = argv.webrtc !== undefined || argv.share !== undefined;
+  const wantHttp = argv.http === true || argv.share !== undefined || argv.webrtc === undefined;
+  const fixedPort = typeof argv.port === "number";
+  const usePortless = wantHttp && !fixedPort;
+  if (argv.local === true && fixedPort) {
+    process.stderr.write("ay serve: --local and --port cannot be used together\n");
+    return 1;
+  }
+  if (usePortless && process.env[PORTLESS_CHILD_ENV] !== "1" && process.env.PORTLESS !== "0") {
+    return runWithPortless(rest);
+  }
+
   // `ay serve` takes only flags (plus the install/uninstall/logs subcommands
   // handled above). A bare word like `ay serve share` is silently dropped into
   // argv._ by yargs and would otherwise start in the wrong mode — most often
@@ -1260,7 +1366,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
   // top-level agents regardless of the spawn path.
   delete process.env.AGENT_YES_PID;
 
-  const port = (argv.port as number) ?? DEFAULT_PORT;
+  const port = (argv.port as number | undefined) ?? (Number(process.env.PORT) || DEFAULT_PORT);
   const host = (argv.host as string) ?? "127.0.0.1";
   const tokenFlag = typeof argv.token === "string" ? argv.token : undefined;
   const certPath = typeof argv["tls-cert"] === "string" ? argv["tls-cert"] : undefined;
@@ -1276,8 +1382,6 @@ export async function cmdServe(rest: string[]): Promise<number> {
   // Modes: --http (HTTP listener + web console), --webrtc (port-free WebRTC
   // share), or both. Bare `ay serve` stays HTTP-only; --share keeps its old
   // meaning (HTTP + WebRTC) for existing invocations.
-  const wantWebrtc = argv.webrtc !== undefined || argv.share !== undefined;
-  const wantHttp = argv.http === true || argv.share !== undefined || argv.webrtc === undefined;
 
   // Singleton WebRTC host per ~/.agent-yes: a second host joining the SAME
   // persisted room (~/.agent-yes/.share-room) fights the first over every
@@ -1435,6 +1539,28 @@ export async function cmdServe(rest: string[]): Promise<number> {
     }
   };
 
+  // Per-agent live status description from the rendered screen. Claude Code
+  // paints a spinner/status line while working; surfacing it lets the left panel
+  // show "what it's doing" without opening the terminal.
+  const statusTextCache = new Map<
+    string,
+    { size: number; mtimeMs: number; statusText: string | null }
+  >();
+  const logStatusText = async (logFile: string | null | undefined): Promise<string | null> => {
+    if (!logFile) return null;
+    try {
+      const { size, mtimeMs } = await stat(logFile);
+      const hit = statusTextCache.get(logFile);
+      if (hit && hit.size === size && hit.mtimeMs === mtimeMs) return hit.statusText;
+      const lines = await renderLogTailLines(logFile, 40);
+      const statusText = lines ? parseStatusText(lines) : null;
+      statusTextCache.set(logFile, { size, mtimeMs, statusText });
+      return statusText;
+    } catch {
+      return null;
+    }
+  };
+
   // Per-agent "waiting on you" detection: the agent is parked on an interactive
   // menu it did NOT auto-resolve (config `needsInput` patterns). Same source and
   // classifier as `ay ls` / `ay status`, so the console's dot matches the CLI's
@@ -1701,6 +1827,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
       // WHAT the agent is waiting on. Null otherwise.
       question,
       title: await logTitle(r.log_file),
+      status_text: status === "exited" ? null : await logStatusText(r.log_file),
       git: status === "exited" ? null : await gitStatus(r.cwd),
       // Task progress from the rendered todo block (null when none detected → no
       // badge). Skipped for exited agents — their screen is no longer live.
@@ -3208,17 +3335,20 @@ export async function cmdServe(rest: string[]): Promise<number> {
     // server is null only when we degraded to WebRTC-only above (port wedged);
     // skip the HTTP connection banner since nothing is listening on the port.
     if (server) {
+      const listenPort = server.port;
       const uiHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
-      process.stdout.write(`ay serve  ${scheme}://${host}:${port}\n`);
+      process.stdout.write(`ay serve  ${scheme}://${host}:${listenPort}\n`);
       process.stdout.write(`token:    ${token}\n\n`);
       process.stdout.write(`web console (token in the # is eaten on open):\n`);
-      process.stdout.write(`  ${scheme}://${uiHost}:${port}/#k=${token}\n\n`);
+      process.stdout.write(
+        `  ${usePortless ? portlessConsoleUrl(token) : `${scheme}://${uiHost}:${listenPort}/#k=${token}`}\n\n`,
+      );
       process.stdout.write(`connect from another machine:\n`);
-      process.stdout.write(`  ay ls   ${token}@<host>:${port}\n`);
-      process.stdout.write(`  ay tail ${token}@<host>:${port}:<keyword>\n`);
-      process.stdout.write(`  ay send ${token}@<host>:${port}:<keyword> "message"\n\n`);
+      process.stdout.write(`  ay ls   ${token}@<host>:${listenPort}\n`);
+      process.stdout.write(`  ay tail ${token}@<host>:${listenPort}:<keyword>\n`);
+      process.stdout.write(`  ay send ${token}@<host>:${listenPort}:<keyword> "message"\n\n`);
       process.stdout.write(`save as alias:\n`);
-      process.stdout.write(`  ay remote add <alias> ${scheme}://${token}@<host>:${port}\n\n`);
+      process.stdout.write(`  ay remote add <alias> ${scheme}://${token}@<host>:${listenPort}\n\n`);
       if (!useHttps) {
         process.stdout.write(
           `for HTTPS: ay serve --tls-cert cert.pem --tls-key key.pem\n` +

package/ts/share.ts

@@ -66,10 +66,28 @@ const MAX_PEER_JOIN_QUEUE = 50;
 const IDLE_RESTART_UPTIME_MS = 25 * 60_000;
 const HARD_RESTART_UPTIME_MS = 45 * 60_000;
 const IDLE_RESTART_CHECK_MS = 60_000;
+const PERF_SLOW_MS = Number(process.env.AGENT_YES_WEBRTC_PERF_SLOW_MS) || 750;
+const PERF_BUFFERED_BYTES = Number(process.env.AGENT_YES_WEBRTC_PERF_BUFFERED_BYTES) || 1_000_000;
+const PERF_VERBOSE = process.env.AGENT_YES_WEBRTC_PERF === "1";
 
 type IceServer = { urls: string | string[]; username?: string; credential?: string };
 const STUN: IceServer[] = [{ urls: "stun:stun.l.google.com:19302" }];
 
+function perfLog(event: string, data: Record<string, unknown>, force = false) {
+  if (!force && !PERF_VERBOSE) return;
+  process.stderr.write(`[share:perf] ${JSON.stringify({ t: Date.now(), event, ...data })}\n`);
+}
+
+function maybeSlow(event: string, startedAt: number, data: Record<string, unknown> = {}) {
+  const ms = Math.round(performance.now() - startedAt);
+  perfLog(event, { ms, ...data }, ms >= PERF_SLOW_MS);
+}
+
+function dcBufferedAmount(dc: any): number {
+  const n = Number(dc?.bufferedAmount ?? 0);
+  return Number.isFinite(n) ? n : 0;
+}
+
 // Short-lived Cloudflare TURN credentials, minted from a long-term TURN key, so
 // browsers can RELAY when a direct P2P path is impossible (symmetric NAT /
 // CGNAT — the main cause of "rooms offline"). Set CF_TURN_KEY_ID +
@@ -428,6 +446,7 @@ export async function startShare(
     if (closed) return; // a reconnect timer queued before close() must not revive it
     const ws = new WebSocket(`${wsScheme}://${host}/${room}`, [SUB]);
     currentWs = ws;
+    const signalStartedAt = performance.now();
     let ready = false;
     let lastRecv = Date.now();
     let hb: ReturnType<typeof setInterval> | undefined;
@@ -443,6 +462,7 @@ export async function startShare(
       }
     };
     ws.onopen = () => {
+      maybeSlow("signal.open", signalStartedAt, { room, host });
       ws.send(JSON.stringify({ type: "hello", role: "host", v: 2, token: authToken }));
       ready = true;
       lastRecv = Date.now();
@@ -480,6 +500,12 @@ export async function startShare(
       const m = JSON.parse(ev.data as string);
       if (m.type === "pong") return; // heartbeat ack — liveness already recorded
       if (m.type === "peer-join") {
+        perfLog("peer.join", {
+          room,
+          peer: String(m.peer),
+          queue: peerJoinQueue.length,
+          peers: peers.size,
+        });
         // Serialized in drainPeerJoins() to avoid a storm. Skip dupes (already
         // queued or already an active peer) and cap the queue so a pathological
         // burst can't grow it unboundedly — dropped joins retry via the browser.
@@ -554,6 +580,7 @@ export async function startShare(
   };
 
   async function startPeer(ws: WebSocket, peerId: string) {
+    const startedAt = performance.now();
     const iceServers = await getIceServers();
     const pc = new RTCPeerConnection({ iceServers });
     let resolveKeys!: () => void;
@@ -584,6 +611,11 @@ export async function startShare(
     dc.binaryType = "arraybuffer";
     dc.onopen = async () => {
       try {
+        maybeSlow("peer.dc_open", startedAt, {
+          room,
+          peer: peerId,
+          buffered: dcBufferedAmount(dc),
+        });
         await peer.keysReady; // keys derived in the answer handler
         // Open the mandatory bidirectional key-confirmation handshake. Nothing
         // the peer sends is acted on until BOTH directions confirm (see onFrame).
@@ -624,6 +656,7 @@ export async function startShare(
     ws.send(
       JSON.stringify({ type: "offer", to: peerId, sdp: pc.localDescription.sdp, iceServers }),
     );
+    maybeSlow("peer.offer", startedAt, { room, peer: peerId, iceServers: iceServers.length });
   }
 
   function closePeer(peerId: string) {
@@ -642,8 +675,10 @@ export async function startShare(
   // Seal an envelope and send it, serialized per peer so the wire order matches
   // the nonce-counter order (so the receiver's monotonic check never trips).
   function enqueueSeal(peerId: string, dc: any, peer: Peer, flags: number, obj: object) {
+    const queuedAt = performance.now();
     peer.sendChain = peer.sendChain.then(async () => {
       if (dc.readyState !== "open" || !peer.keyH2C || !peer.th) return;
+      const queuedMs = Math.round(performance.now() - queuedAt);
       let frame: ArrayBuffer;
       try {
         frame = await e2eSeal(peer.keyH2C, peer.send, flags, peer.th, packEnvelope(obj));
@@ -653,6 +688,19 @@ export async function startShare(
       }
       try {
         dc.send(frame);
+        const buffered = dcBufferedAmount(dc);
+        perfLog(
+          "send",
+          {
+            room,
+            peer: peerId,
+            kind: (obj as any)?.t,
+            queuedMs,
+            buffered,
+            bytes: frame.byteLength,
+          },
+          queuedMs >= PERF_SLOW_MS || buffered >= PERF_BUFFERED_BYTES,
+        );
       } catch {
         /* peer vanished mid-send; dropping the frame is correct */
       }
@@ -703,6 +751,8 @@ export async function startShare(
     }
     if (req.t !== "req") return;
     const { id, method, path: p, body } = req;
+    const startedAt = performance.now();
+    perfLog("req.start", { room, peer: peerId, id, method, path: p });
     const ac = new AbortController();
     peer.aborts.set(id, ac);
     try {
@@ -718,6 +768,14 @@ export async function startShare(
           signal: ac.signal,
         }),
       );
+      maybeSlow("req.head", startedAt, {
+        room,
+        peer: peerId,
+        id,
+        method,
+        path: p,
+        status: res.status,
+      });
       enqueueSeal(peerId, dc, peer, 0, {
         t: "res",
         id,
@@ -727,9 +785,11 @@ export async function startShare(
       const reader = res.body!.getReader();
       const dec = new TextDecoder();
       let seq = 0;
+      let bytes = 0;
       for (;;) {
         const { done, value } = await reader.read();
         if (done) break;
+        bytes += value.byteLength;
         const text = dec.decode(value, { stream: true });
         // Slice on UTF-16 boundaries: JSON round-trips lone surrogates as \uXXXX,
         // so the receiver reassembles the exact text by concatenating in seq order.
@@ -742,13 +802,32 @@ export async function startShare(
           });
       }
       enqueueSeal(peerId, dc, peer, 0, { t: "end", id, seq });
+      maybeSlow("req.end", startedAt, {
+        room,
+        peer: peerId,
+        id,
+        method,
+        path: p,
+        status: res.status,
+        chunks: seq,
+        bytes,
+      });
     } catch (e) {
-      if ((e as Error).name !== "AbortError")
+      if ((e as Error).name !== "AbortError") {
+        maybeSlow("req.error", startedAt, {
+          room,
+          peer: peerId,
+          id,
+          method,
+          path: p,
+          error: String((e as Error).message ?? e),
+        });
         enqueueSeal(peerId, dc, peer, 0, {
           t: "end",
           id,
           error: String((e as Error).message ?? e),
         });
+      }
     } finally {
       peer.aborts.delete(id);
     }

package/ts/statusText.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { parseStatusText } from "./statusText.ts";
+
+describe("parseStatusText", () => {
+  it("returns the latest Claude spinner/status line", () => {
+    expect(
+      parseStatusText([
+        "older output",
+        "✶ Verifying calendar meetings with real data… (6m 30s · ↓ 19.5k tokens)",
+      ]),
+    ).toBe("✶ Verifying calendar meetings with real data… (6m 30s · ↓ 19.5k tokens)");
+  });
+
+  it("ignores non-status terminal prose", () => {
+    expect(parseStatusText(["hello", "Done", ""])).toBe(null);
+  });
+});

package/ts/statusText.ts

@@ -0,0 +1,19 @@
+/**
+ * Extract a short "what is the agent doing right now?" line from the rendered
+ * terminal screen. Claude Code paints this as a spinner/status line, e.g.
+ * "✶ Verifying calendar meetings with real data… (6m 30s · ↓ 19.5k tokens)".
+ */
+
+const SPINNER_PREFIX = /^[\u2800-\u28ff✶✻✢✳✽✦✧✩✷✸✹✺✼·•●◐◓◒◑]\s+/u;
+const CONTROL = /[\x00-\x1f\x7f-\x9f]/g;
+
+export function parseStatusText(lines: string[]): string | null {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]?.replace(CONTROL, "").trim();
+    if (!line || line.length < 3) continue;
+    if (!SPINNER_PREFIX.test(line)) continue;
+    if (/^(?:[•·]\s*)?(?:esc|ctrl|enter|return|shift|tab)\b/i.test(line)) continue;
+    return line.slice(0, 220).trim();
+  }
+  return null;
+}

package/dist/SUPPORTED_CLIS-D3XTFfS7.js

@@ -1,9 +0,0 @@
-import "./ts-Dm6jjLwC.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-BomfUpSo.js";
-import "./pidStore-BIvsBQ8X.js";
-import "./globalPidIndex-CoNr7tS8.js";
-import "./messageLog-CxrKJj77.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-C8-qh98a.js";
-
-export { SUPPORTED_CLIS };