ompchamber 3.1.0 → 3.2.0

package/src/server/routes/agent/ws.ts

@@ -9,7 +9,7 @@
  *
  * Same frame vocabulary (JSON objects with a `type`, first frame `connected`),
  * same backpressure policy (replaceable `message_update` frames collapse to the
- * latest one while the client is behind) — the policy itself now lives in
+ * latest one while the client is behind) — the policy itself lives in
  * `createEventCoalescer`, shared with the SSE route — but carried by one duplex
  * socket: no per-event HTTP framing, no browser reconnect storm, and
  * protocol-level ping/pong keepalive instead of a comment frame every 30s.
@@ -17,18 +17,18 @@
  * Transport-only by design. It reads the live session registry off `globalThis`
  * (the map the server build populates) and duck-types the wrapper, so the
  * registry contract survives any HTTP framework owning the port.
+ *
+ * **Per-connection state lives on `ws.data`, not in a `WeakMap` keyed by the
+ * `ws` object.** Elysia's Bun adapter builds a fresh wrapper per callback and
+ * hands `pong` the raw socket, so a WeakMap lookup always missed: the pong
+ * never cleared `awaitingPong` and the second heartbeat closed a healthy
+ * socket at 60s, while `close` leaked the interval and the session
+ * subscription. `attachObserverStream` owns the lifecycle; see
+ * `@/server/lib/observer-ws` for the measurements.
  */
 
 import { Elysia, t } from 'elysia';
-import { createEventCoalescer, type EventCoalescer } from '@/server/lib/sse';
-import { STREAM_HEARTBEAT_MS } from '@/shared/lib/workspace/refresh-cadence';
-
-/** Coalesce `message_update` frames once this many bytes sit unsent. */
-const HIGH_WATER_BYTES = 256 * 1024;
-
-/** Longest a coalesced frame may wait before it is flushed anyway, so a burst
- *  that ends while the socket is still busy never strands the newest update. */
-const FLUSH_DELAY_MS = 50;
+import { attachObserverStream, createObserverState, type ObserverConnectionState } from '@/server/lib/observer-ws';
 
 interface AgentEventSession {
   isAlive?: () => boolean;
@@ -48,15 +48,8 @@ function findAgentSession(sessionId: string): AgentEventSession | null {
   return session;
 }
 
-interface ConnectionState {
-  closed: boolean;
-  unsubscribe: (() => void) | null;
-  heartbeat: ReturnType<typeof setInterval> | null;
-  awaitingPong: boolean;
-  coalescer: EventCoalescer | null;
-}
-
-const connections = new WeakMap<object, ConnectionState>();
+/** Elysia's ws context, narrowed to the per-connection store this route adds. */
+type AgentWsData = { params: { sessionId: string }; observer?: ObserverConnectionState };
 
 export const agentWsRoutes = new Elysia({ prefix: '/api/agent' }).ws('/:sessionId/ws', {
   params: t.Object({ sessionId: t.String() }),
@@ -68,81 +61,24 @@ export const agentWsRoutes = new Elysia({ prefix: '/api/agent' }).ws('/:sessionI
   },
 
   open(ws) {
-    const sessionId = ws.data.params.sessionId;
+    const data = ws.data as unknown as AgentWsData;
+    const sessionId = data.params.sessionId;
     const session = findAgentSession(sessionId);
     if (!session) {
       ws.close();
       return;
     }
 
-    const state: ConnectionState = {
-      closed: false,
-      unsubscribe: null,
-      heartbeat: null,
-      awaitingPong: false,
-      coalescer: null,
-    };
-    connections.set(ws, state);
+    const state = createObserverState();
+    data.observer = state;
+    const { push } = attachObserverStream(state, ws);
 
-    const teardown = () => {
-      if (state.closed) return;
-      state.closed = true;
-      state.coalescer?.dispose();
-      state.coalescer = null;
-      if (state.heartbeat !== null) {
-        clearInterval(state.heartbeat);
-        state.heartbeat = null;
-      }
-      if (state.unsubscribe) {
-        try {
-          state.unsubscribe();
-        } catch {
-          // Subscriber cleanup is best-effort.
-        }
-        state.unsubscribe = null;
-      }
-      try {
-        ws.close();
-      } catch {
-        // Already gone.
-      }
-    };
-
-    state.coalescer = createEventCoalescer({
-      send: (_event, data) => {
-        try {
-          ws.send(JSON.stringify(data));
-        } catch {
-          teardown();
-        }
-      },
-      isBackpressured: () => ((ws.raw as { bufferedAmount?: number }).bufferedAmount ?? 0) > HIGH_WATER_BYTES,
-      flushDelayMs: FLUSH_DELAY_MS,
-    });
-
-    // Protocol-level keepalive: a client that misses a full ping cycle is gone,
-    // and a live one answers without any application-level traffic.
-    state.heartbeat = setInterval(() => {
-      if (state.closed) return;
-      if (state.awaitingPong) {
-        teardown();
-        return;
-      }
-      state.awaitingPong = true;
-      if (!state.coalescer?.flush()) return;
-      try {
-        (ws.raw as { ping?: () => void }).ping?.();
-      } catch {
-        teardown();
-      }
-    }, STREAM_HEARTBEAT_MS);
-
-    state.unsubscribe = session.onEvent((event) => state.coalescer?.push('', event));
-    state.coalescer.push('', { type: 'connected', sessionId });
+    state.unsubscribe = session.onEvent((event) => push('', event));
+    push('', { type: 'connected', sessionId });
   },
 
   pong(ws) {
-    const state = connections.get(ws);
+    const state = (ws.data as unknown as AgentWsData).observer;
     if (state) state.awaitingPong = false;
   },
 
@@ -151,18 +87,7 @@ export const agentWsRoutes = new Elysia({ prefix: '/api/agent' }).ws('/:sessionI
   },
 
   close(ws) {
-    const state = connections.get(ws);
-    if (!state || state.closed) return;
-    state.closed = true;
-    state.coalescer?.dispose();
-    state.coalescer = null;
-    if (state.heartbeat !== null) clearInterval(state.heartbeat);
-    if (state.unsubscribe) {
-      try {
-        state.unsubscribe();
-      } catch {
-        // Subscriber cleanup is best-effort.
-      }
-    }
+    const state = (ws.data as unknown as AgentWsData).observer;
+    if (state) state.teardown();
   },
 });

package/src/server/routes/btw/ws.ts

@@ -12,105 +12,43 @@
  * A client that attaches replays nothing: the socket's first `btw_state` is
  * the session's current history, so a reload lands on the same panel a live
  * stream would have produced.
+ *
+ * **Per-connection state lives on `ws.data`, not in a `WeakMap` keyed by the
+ * `ws` object** — Elysia's Bun adapter hands `pong` the raw socket and a fresh
+ * wrapper to every other callback, so a WeakMap lookup always missed and the
+ * second heartbeat closed a healthy socket. See `@/server/lib/observer-ws`.
  */
 
 import { Elysia, t } from 'elysia';
-import { createEventCoalescer, type EventCoalescer } from '@/server/lib/sse';
-import { STREAM_HEARTBEAT_MS } from '@/shared/lib/workspace/refresh-cadence';
+import { attachObserverStream, createObserverState, type ObserverConnectionState } from '@/server/lib/observer-ws';
 import { btwStateFor, subscribeBtw } from '@/server/lib/btw/registry.server';
 import type { BtwFrame } from '@/shared/types';
 
-/** Coalesce frames once this many bytes sit unsent. */
-const HIGH_WATER_BYTES = 256 * 1024;
-
-/** Longest a coalesced frame may wait before it is flushed anyway. */
-const FLUSH_DELAY_MS = 50;
-
-interface ConnectionState {
-  closed: boolean;
-  unsubscribe: (() => void) | null;
-  heartbeat: ReturnType<typeof setInterval> | null;
-  awaitingPong: boolean;
-  coalescer: EventCoalescer | null;
-}
-
-const connections = new WeakMap<object, ConnectionState>();
+/** Elysia's ws context, narrowed to the per-connection store this route adds. */
+type BtwWsData = { params: { sessionId: string }; observer?: ObserverConnectionState };
 
 export const btwWsRoutes = new Elysia({ prefix: '/api/btw' }).ws('/:sessionId/ws', {
   params: t.Object({ sessionId: t.String() }),
 
   open(ws) {
-    const sessionId = ws.data.params.sessionId;
-    const state: ConnectionState = { closed: false, unsubscribe: null, heartbeat: null, awaitingPong: false, coalescer: null };
-    connections.set(ws, state);
-    // Unchecked: Elysia exposes the server socket untyped. Both members are
-    // optional, so an absent one degrades (no byte count / no keepalive)
-    // instead of failing.
-    const raw = ws.raw as { bufferedAmount?: number; ping?: () => void };
-
-    const teardown = () => {
-      if (state.closed) return;
-      state.closed = true;
-      state.coalescer?.dispose();
-      state.coalescer = null;
-      if (state.heartbeat !== null) {
-        clearInterval(state.heartbeat);
-        state.heartbeat = null;
-      }
-      if (state.unsubscribe) {
-        try {
-          state.unsubscribe();
-        } catch {
-          // Subscriber cleanup is best-effort.
-        }
-        state.unsubscribe = null;
-      }
-      try {
-        ws.close();
-      } catch {
-        // Already gone.
-      }
-    };
-
-    state.coalescer = createEventCoalescer({
-      send: (_event, data) => {
-        try {
-          ws.send(JSON.stringify(data));
-        } catch {
-          teardown();
-        }
-      },
-      isBackpressured: () => (raw.bufferedAmount ?? 0) > HIGH_WATER_BYTES,
-      flushDelayMs: FLUSH_DELAY_MS,
-    });
-
-    state.heartbeat = setInterval(() => {
-      if (state.closed) return;
-      if (state.awaitingPong) {
-        teardown();
-        return;
-      }
-      state.awaitingPong = true;
-      if (!state.coalescer?.flush()) return;
-      try {
-        raw.ping?.();
-      } catch {
-        teardown();
-      }
-    }, STREAM_HEARTBEAT_MS);
-
-    const push = (frame: BtwFrame) => state.coalescer?.push('', frame);
-    state.unsubscribe = subscribeBtw(sessionId, push);
-    push({ type: 'connected', sessionId });
+    const data = ws.data as unknown as BtwWsData;
+    const sessionId = data.params.sessionId;
+    const state = createObserverState();
+    data.observer = state;
+    const { push } = attachObserverStream(state, ws);
+
+    const send = (frame: BtwFrame) => push('', frame);
+    state.unsubscribe = subscribeBtw(sessionId, send);
+    send({ type: 'connected', sessionId });
     void btwStateFor(sessionId)
-      .then((snapshot) => push({ type: 'btw_state', state: snapshot }))
+      .then((snapshot) => send({ type: 'btw_state', state: snapshot }))
       .catch((error: unknown) => {
-        push({ type: 'btw_error', topicId: null, message: error instanceof Error ? error.message : String(error) });
+        send({ type: 'btw_error', topicId: null, message: error instanceof Error ? error.message : String(error) });
       });
   },
 
   pong(ws) {
-    const state = connections.get(ws);
+    const state = (ws.data as unknown as BtwWsData).observer;
     if (state) state.awaitingPong = false;
   },
 
@@ -119,18 +57,7 @@ export const btwWsRoutes = new Elysia({ prefix: '/api/btw' }).ws('/:sessionId/ws
   },
 
   close(ws) {
-    const state = connections.get(ws);
-    if (!state || state.closed) return;
-    state.closed = true;
-    state.coalescer?.dispose();
-    state.coalescer = null;
-    if (state.heartbeat !== null) clearInterval(state.heartbeat);
-    if (state.unsubscribe) {
-      try {
-        state.unsubscribe();
-      } catch {
-        // Subscriber cleanup is best-effort.
-      }
-    }
+    const state = (ws.data as unknown as BtwWsData).observer;
+    if (state) state.teardown();
   },
 });

package/src/server/routes/fs/git.ts

@@ -1,65 +1,26 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `GET /api/fs/git` — the Source Control panel's data, and the file-diff /
+ * commit-history endpoints the diff panel and commit modal read.
+ *
+ * Repository discovery (`?reposOnly=1`) is a background walk over the scoped
+ * root; see `lib/fs/git-repos.ts`. This module owns the request shapes.
+ */
+
 import { json, type ActionFunctionArgs, type LoaderFunctionArgs } from '@/server/lib/remix-compat';
 import fs from 'fs';
 import path from 'path';
 import { resolveRoot } from '@/server/lib/fs/root';
 import { runShell } from '@/server/lib/fs/shell';
+import { discoveredRepos, rescanRepos, startRepoScan } from '@/server/lib/fs/git-repos';
 import { fetchFileDiff, fetchGitCommits } from '@/server/lib/fs/git-log';
 import { fetchWorkingFileDiff } from '@/server/lib/fs/git-diff';
 import { gitSyncCount, invalidateRemoteRefs, markRemoteRefsFresh, refreshRemoteRefs } from '@/server/lib/fs/git-sync';
 
-const MAX_GIT_DEPTH = 8;
-
-async function getRepos(rootDir: string): Promise<string[]> {
-  try {
-    // Search deep enough to discover nested/child git repos inside a monorepo
-    // workspace (e.g. projects/<name>/<sub>/.git) while pruning node_modules.
-    const result = await runShell(
-      `find . -maxdepth ${MAX_GIT_DEPTH} -name node_modules -prune -o -name .git -type d -print`,
-      { cwd: rootDir, timeout: 12000, maxBuffer: 1024 * 1024 }
-    );
-    const discovered = result.stdout
-      .trim()
-      .split('\n')
-      .filter(Boolean)
-      .map(line => {
-        const cleaned = line.replace(/^\.\//, '').replace(/\/\.git$/, '');
-        return cleaned === '.git' || !cleaned ? '.' : cleaned;
-      });
-
-    const uniqueRepos = Array.from(new Set(discovered));
-    if (uniqueRepos.includes('.')) {
-      return ['.', ...uniqueRepos.filter(r => r !== '.')];
-    }
-    return uniqueRepos.length ? uniqueRepos : ['.'];
-  } catch {
-    return ['.'];
-  }
-}
-
-// Nested-repo discovery is expensive (find over a deep workspace), so it runs
-// in the background after the loader returns the root status. Results are
-// cached per scoped root and the client polls `?reposOnly=1` until ready.
-interface RepoDiscovery {
-  repos: string[];
-  done: boolean;
-}
-const repoDiscovery = new Map<string, RepoDiscovery>();
-
-function startRepoScan(rootDir: string): void {
-  if (repoDiscovery.has(rootDir)) return;
-  const d: RepoDiscovery = { repos: ['.'], done: false };
-  repoDiscovery.set(rootDir, d);
-  void getRepos(rootDir)
-    .then(repos => { d.repos = repos; d.done = true; })
-    .catch(() => { d.repos = ['.']; d.done = true; });
-}
-
-function discoveredRepos(rootDir: string): { repos: string[]; pending: boolean } {
-  const d = repoDiscovery.get(rootDir);
-  if (!d) return { repos: ['.'], pending: false };
-  return { repos: d.done ? d.repos : ['.'], pending: !d.done };
-}
-
 export async function loader({ request }: LoaderFunctionArgs) {
   const url = new URL(request.url);
   const rootDir = await resolveRoot(url.searchParams.get('root'), process.cwd());
@@ -68,10 +29,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
   // whatever is already cached. `rescan=1` invalidates the cache so a fresh
   // discovery pass starts (used by the repo-switcher refresh button).
   const rescan = url.searchParams.get('rescan') === '1';
-  if (rescan) {
-    repoDiscovery.delete(rootDir);
-  }
-  startRepoScan(rootDir);
+  if (rescan) rescanRepos(rootDir);
+  else startRepoScan(rootDir);
   const { repos, pending } = discoveredRepos(rootDir);
 
   // Lightweight polling endpoint: just the discovered repos, no git status.
@@ -98,7 +57,8 @@ export async function loader({ request }: LoaderFunctionArgs) {
     if (targetFile) {
       const staged = url.searchParams.get('staged') === '1' || url.searchParams.get('staged') === 'true';
       const statusParam = url.searchParams.get('status') || undefined;
-      const diffData = await fetchWorkingFileDiff(targetDir, targetFile, staged, statusParam);
+      const fullContext = url.searchParams.get('fullContext') === '1';
+      const diffData = await fetchWorkingFileDiff(targetDir, targetFile, staged, statusParam, fullContext);
       return json({ success: true, ...diffData });
     }
   }
@@ -133,23 +93,54 @@ export async function loader({ request }: LoaderFunctionArgs) {
     const statusOut = (await runShell('git status --porcelain=v1 -uall', { cwd: targetDir, maxBuffer: 1024 * 1024 })).stdout;
 
     let branch = 'main';
-    let branches: string[] = ['main'];
-    let remoteBranches: string[] = [];
+    // Seeded empty, not `['main']`: the seed used to be pushed as a real local
+    // branch, so a repository whose only branch is `main` listed it twice.
+    const branches: string[] = [];
+    const remoteBranches: string[] = [];
     try {
-      const branchOut = await runShell('git rev-parse --abbrev-ref HEAD', { cwd: targetDir });
-      branch = branchOut.stdout.trim() || 'main';
-
-      const localOut = await runShell('git branch --format="%(refname:short)"', { cwd: targetDir });
-      branches = localOut.stdout.trim().split('\n').filter(Boolean);
-
-      const remoteOut = await runShell('git branch -r --format="%(refname:short)"', { cwd: targetDir });
-      remoteBranches = remoteOut.stdout.trim().split('\n').filter(Boolean).filter(b => b.includes('/') && !b.endsWith('/HEAD'));
-      if (!branches.includes(branch)) {
-        branches.unshift(branch);
+      // One `for-each-ref` answers all three questions the three previous
+      // spawns asked separately (`rev-parse --abbrev-ref HEAD`, `branch`,
+      // `branch -r`): `%(HEAD)` marks the checked-out branch with `*`, and the
+      // two refspecs cover local and remote in one listing. Measured 8.15 ms
+      // against 19.63 ms for the three-call form, on a 5s poll.
+      //
+      // Classification reads the FULL refname: `%(refname:short)` maps
+      // `refs/remotes/origin/HEAD` to the bare `origin`, which has no slash and
+      // would otherwise be listed as a local branch.
+      const refsOut = (await runShell(
+        'git for-each-ref --format="%(refname)%09%(refname:short)%09%(HEAD)" refs/heads refs/remotes',
+        { cwd: targetDir },
+      )).stdout;
+      let sawHead = false;
+      for (const line of refsOut.split('\n')) {
+        const [full, short, head] = line.split('\t');
+        if (!full || !short) continue;
+        // `refs/remotes/origin/HEAD` is a symbolic alias, not a branch.
+        if (full.endsWith('/HEAD')) continue;
+        if (full.startsWith('refs/remotes/')) {
+          remoteBranches.push(short);
+          continue;
+        }
+        branches.push(short);
+        if (head === '*') {
+          branch = short;
+          sawHead = true;
+        }
+      }
+      // Detached HEAD: no local ref is marked, and the branch is the sha
+      // `rev-parse --abbrev-ref HEAD` prints. Ask for it rather than reporting
+      // a branch the checkout is not on.
+      if (!sawHead) {
+        const headOut = await runShell('git rev-parse --abbrev-ref HEAD', { cwd: targetDir });
+        branch = headOut.stdout.trim() || 'main';
       }
     } catch {
       // ignore branch resolution errors
     }
+    // `main` remains the answer only when nothing could be read (a non-repo
+    // directory, git missing) — a real listing always supplies its own refs.
+    if (branches.length === 0) branches.push('main');
+    else if (!branches.includes(branch)) branches.unshift(branch);
 
     const changes = statusOut
       .split('\n')

package/src/server/routes/omp/session-stats.ts

@@ -22,7 +22,7 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const resolved = await resolveSessionFileOr404(sessionId);
   if ('response' in resolved) return resolved.response;
   const { filePath } = resolved;
-  const stats = readSessionStats(filePath);
+  const stats = await readSessionStats(filePath);
   if (!stats) {
     return json({ error: 'Session could not be parsed' }, { status: 500 });
   }

package/src/server/routes/telemetry/tokens.ts

@@ -4,7 +4,7 @@ import { methodNotAllowed } from '@/server/lib/route-adapter';
 import { BREAKDOWN_DATA, MOCK_CHART_SERIES, MOCK_CUSTOM_RANGE_DATA, MOCK_RANGE_DATA, TIME_RANGES } from '@/client/data/mock/token-usage';
 import { isMockMode } from '@/server/mock.server';
 import { loadModelsDevCatalog } from '@/shared/lib/models/catalog';
-import { aggregateUsage, type UsageWindow } from '@/server/lib/omp/session/usage/aggregate';
+import { aggregateUsageWindows, PRESET_RANGES, type UsageWindow } from '@/server/lib/omp/session/usage/aggregate';
 import { buildChartSeries, toBreakdownRows, toMetricSet } from '@/server/lib/omp/session/usage/shaping';
 import type { BreakdownRow, BreakdownTab, CadenceType, ChartSeriesPoint, TimeRangeType, TokenUsageMetricSet } from '@/shared/types';
 
@@ -22,7 +22,6 @@ const REAL_ZERO_METRIC: TokenUsageMetricSet = {
   usageRecords: 0,
 };
 
-const PRESET_RANGES: Exclude<TimeRangeType, 'custom'>[] = ['today', '7d', '30d', '90d', 'all'];
 const CADENCES: CadenceType[] = ['daily', 'weekly', 'monthly'];
 const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -104,12 +103,15 @@ export async function loader({ request }: LoaderFunctionArgs) {
 
   // Real Mode: aggregate actual token/cost usage from omp session files.
   try {
+    // One scan, every window: the tree read is the expensive part (measured
+    // 795 ms over 455 transcripts), and folding six windows from one scan
+    // replaced six separate reads — 3.3 s cold on this machine.
+    const { ranges, active: activeAggregate } = await aggregateUsageWindows(window);
     const realRangeData = {} as Record<Exclude<TimeRangeType, 'custom'>, TokenUsageMetricSet>;
     for (const range of PRESET_RANGES) {
-      realRangeData[range] = toMetricSet(await aggregateUsage({ kind: 'preset', range }), cadence);
+      realRangeData[range] = toMetricSet(ranges[range], cadence);
     }
 
-    const activeAggregate = await aggregateUsage(window);
     const realBreakdown: Record<BreakdownTab, BreakdownRow[]> = {
       model: toBreakdownRows(activeAggregate, 'model'),
       day: toBreakdownRows(activeAggregate, 'day', cadence),

package/src/server/routes/terminal/run.ts

@@ -14,18 +14,14 @@ export async function loader({ request }: LoaderFunctionArgs) {
   const url = new URL(request.url);
   const rootDir = await resolveRoot(url.searchParams.get('root'), process.cwd());
   const targetDir = await scopeToRepo(rootDir, url.searchParams.get('repo'));
-  let bunVersion = '';
+  // The server IS the Bun being reported, so the version is already in this
+  // process. Spawning `bun --version` through a shell cost 10.4 ms per header
+  // load to read a constant `Bun.version` answers in 0.05 ms.
+  const bunVersion = Bun.version;
   // `process.version` is the Node version Bun emulates, not a real Node binary.
   const nodeVersion = process.version;
   let gitBranch = 'main';
 
-  try {
-    const bunOut = await runShell('bun --version', { cwd: targetDir });
-    bunVersion = bunOut.stdout.trim();
-  } catch {
-    bunVersion = Bun.version;
-  }
-
   try {
     const branchOut = await runShell('git rev-parse --abbrev-ref HEAD', { cwd: targetDir });
     gitBranch = branchOut.stdout.trim() || 'main';

package/src/server/routes/terminal/ws.ts

@@ -66,9 +66,24 @@ export const terminalWsRoutes = new Elysia({ prefix: '/api/terminal' }).ws('/:te
       viewer: {
         send(frame) {
           try {
-            ws.send(frame);
+            // Bun returns -1 when the frame was dropped rather than queued
+            // (the socket is over its high-water mark). Reporting it lets the
+            // session close this viewer instead of buffering a PTY's output
+            // into a socket nobody is reading.
+            return ws.send(frame) !== -1;
           } catch {
             // Socket closed mid-send; the close handler detaches.
+            return false;
+          }
+        },
+        drop() {
+          // The terminal session removed this viewer; close the socket so the
+          // client reconnects and replays the scrollback rather than sitting
+          // on a stream with a hole in it.
+          try {
+            ws.close();
+          } catch {
+            // Already gone.
           }
         },
       },
@@ -114,7 +129,14 @@ export const terminalWsRoutes = new Elysia({ prefix: '/api/terminal' }).ws('/:te
       // Ordering is safe without sequence numbers: attach captured the history
       // and registered this viewer in one synchronous block, so nothing can be
       // delivered between this frame and the replay that follows it.
-      if (replay.length > 0) ws.send(replay);
+      //
+      // The replay goes through the viewer, so a socket that cannot take the
+      // scrollback is closed rather than left attached to a terminal whose
+      // first screenful was silently dropped.
+      if (replay.length > 0 && !attachment.viewer.send(replay)) {
+        detachTerminal(attachment.viewer, attachment.id);
+        attachment.viewer.drop();
+      }
     } catch (error) {
       const code = error instanceof TerminalRuntimeError ? error.code : 'unknown';
       const message = error instanceof Error ? error.message : String(error);

package/src/shared/lib/chat/omp/agent-events.test.ts

@@ -27,12 +27,14 @@ function makeDeps() {
   const activity: string[] = [];
   const commandOutputs: string[] = [];
   let settledCount = 0;
+  let runEnds = 0;
   let state: OmpAgentState = { isGenerating: false, connected: true, error: null };
   const callbacks: OmpAgentCallbacks = {
     onMessageEnd: (msg) => ended.push(msg),
     onActivity: (verb) => activity.push(verb),
     onPromptSettled: () => { settledCount += 1; },
     onCommandOutput: (text) => commandOutputs.push(text),
+    onAgentEnd: () => { runEnds += 1; },
   };
   const deps: OmpAgentFoldDeps = {
     sessionId: 's1',
@@ -47,7 +49,7 @@ function makeDeps() {
     currentThinkingLevelRef: { current: undefined },
     fileMutatingCallsRef: { current: new Set<string>() },
   };
-  return { deps, ended, activity, commandOutputs, settled: () => settledCount, state: () => state };
+  return { deps, ended, activity, commandOutputs, settled: () => settledCount, runEnds: () => runEnds, state: () => state };
 }
 
 describe('toChatMessage error derivation', () => {
@@ -185,4 +187,34 @@ describe('foldAgentEvent agent_end', () => {
     foldAgentEvent({ type: 'agent_end', messages: [{ ...ABORTED_TURN, stopReason: 'end_turn' }] }, deps);
     expect(ended).toHaveLength(0);
   });
+
+  test('a non-terminal agent_end keeps the run generating and does not fire onAgentEnd', () => {
+    // omp's shape when the turn yields with work still alive — a detached
+    // subagent, a compaction, a background job. Measured on omp 18.3.2: with an
+    // async subagent, this frame lands ~14s BEFORE the subagent finishes, and
+    // treating it as the run end blanked the generating indicator for the whole
+    // stretch the roster was still showing a live child.
+    const { deps, state, runEnds } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    expect(state().isGenerating).toBe(true);
+
+    foldAgentEvent({ type: 'agent_end', isTerminal: false, messages: [] }, deps);
+    expect(state().isGenerating).toBe(true);
+    expect(runEnds()).toBe(0);
+
+    // The continuation ends the run for real; only now may the UI settle.
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    foldAgentEvent({ type: 'agent_end', isTerminal: true, messages: [] }, deps);
+    expect(state().isGenerating).toBe(false);
+    expect(runEnds()).toBe(1);
+  });
+
+  test('an agent_end with no isTerminal field is treated as terminal', () => {
+    // The field is optional: a frame that omits it is a normal run end.
+    const { deps, state, runEnds } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    foldAgentEvent({ type: 'agent_end', messages: [] }, deps);
+    expect(state().isGenerating).toBe(false);
+    expect(runEnds()).toBe(1);
+  });
 });

package/src/shared/lib/chat/omp/agent-events.ts

@@ -225,6 +225,16 @@ export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): voi
     }
 
     case 'agent_end': {
+      // A NON-TERMINAL `agent_end` is not the end of the run: omp emits it when
+      // the turn yields but work is still alive — a detached subagent, a
+      // compaction, a background job, or a stop-time reminder — and a later
+      // `agent_start` opens the continuation. Measured on omp 18.3.2: with an
+      // async subagent, `agent_end isTerminal=false` arrives ~13s BEFORE the
+      // subagent's terminal frame, and clearing the generating state there
+      // blanked the indicator for the whole stretch the roster was still
+      // showing a live child. The server's own fold gates on the same field
+      // (frame-fold.ts), so the two ends now agree.
+      if (data.isTerminal === false) break;
       deps.setState((prev) => ({ ...prev, isGenerating: false }));
       deps.activityRef.current = '';
       const terminal = materializeTerminalMessages(data, deps, callbacks ?? undefined);