aicodeman 1.33.2 → 1.34.0

package/dist/web/public/sw.js

@@ -26,7 +26,7 @@
 // not the current one, so the old constant key meant that cleanup never deleted
 // anything — hashed assets from every release ever deployed accumulated in one
 // bucket until the origin hit its storage quota.
-const BUILD_ID = '403212f981d2';
+const BUILD_ID = '5b04d0ba6d2e';
 const CACHE_NAME = `codeman-${BUILD_ID}`;
 
 // Reverse-proxy base path: the worker is served at `<base>/sw.js`, so its own
@@ -48,7 +48,7 @@ const B = (p) => (p && p[0] === '/' ? SW_BASE + p : p);
 // handler caches every successful GET at runtime, but the precache warmed
 // nothing while looking like it did. Deriving it from the same manifest that
 // renames the files is the only thing that keeps the two from drifting again.
-const HASHED_ASSETS = ["styles.3fe3312d.css", "mobile.1aa4952d.css", "constants.cc927eb8.js", "i18n.f094d01f.js", "mobile-handlers.23a85db1.js", "voice-input.c4b51eb6.js", "notification-manager.50bb87d8.js", "keyboard-accessory.c1e7c7b7.js", "input-cjk.8bc46081.js", "terminal-keycode229-recovery.fb91b25b.js", "sanitize-html.bc7078d6.js", "app.91131d2c.js", "tab-rail-resize.dcdc5772.js", "terminal-ui.d5223c0e.js", "respawn-ui.ff0dae4c.js", "ralph-panel.b350e2ef.js", "settings-ui.c68e7f59.js", "panels-ui.67646701.js", "session-ui.7575a231.js", "ralph-wizard.13a1831e.js", "api-client.c9b1cddc.js", "subagent-windows.e6ca799f.js", "image-input.a216cf9e.js", "vendor/xterm-zerolag-input.6fee72f2.js", "vendor/xterm-predictive-echo.bd6882b8.js"];
+const HASHED_ASSETS = ["styles.8c485d26.css", "mobile.1aa4952d.css", "constants.d95fade9.js", "i18n.398b8331.js", "mobile-handlers.23a85db1.js", "voice-input.c4b51eb6.js", "notification-manager.50bb87d8.js", "keyboard-accessory.c1e7c7b7.js", "input-cjk.8bc46081.js", "mobile-ime-preview.2dbaf262.js", "terminal-keycode229-recovery.fb91b25b.js", "sanitize-html.e7147e76.js", "tab-layout-browser.4e0ed50c.js", "app.cf0db8ce.js", "tab-rail-resize.dcdc5772.js", "terminal-ui.a4535311.js", "respawn-ui.ff0dae4c.js", "ralph-panel.b350e2ef.js", "settings-ui.331d3b1d.js", "panels-ui.6a5898d9.js", "session-ui.bf66c13b.js", "ralph-wizard.b6c0dd19.js", "api-client.c9b1cddc.js", "subagent-windows.e6ca799f.js", "image-input.a216cf9e.js", "vendor/xterm-zerolag-input.bbb5f84c.js", "vendor/xterm-predictive-echo.ae5e3d5d.js"];
 
 // Core app shell -- cached on install for instant startup
 const APP_SHELL = [

package/dist/web/public/tab-layout-browser.4e0ed50c.js

@@ -0,0 +1 @@
+"use strict";(function(T){"use strict";const A="codeman:tab-groups-collapsed",$=e=>`${e.kind}:${e.id}`,O=e=>!!e&&(e.kind==="session"||e.kind==="webview")&&typeof e.id=="string"&&e.id.length>0,C=e=>Array.isArray(e)?e.filter(t=>typeof t=="string"&&t):[],f=e=>[...new Set(C(e))],G=e=>Array.isArray(e)?e.filter(O).map(t=>({kind:t.kind,id:t.id})):[];function L(e){if(!e||typeof e!="object")throw new Error("Invalid tab layout");const t=Array.isArray(e.groups)?e.groups:[];return{version:Number.isSafeInteger(e.version)&&e.version>=0?e.version:0,groups:t.filter(n=>n&&typeof n.id=="string"&&n.id.length>0).map(n=>({id:n.id,name:typeof n.name=="string"?n.name:"",refs:G(n.refs)})),ungrouped:G(e.ungrouped)}}function N(e){return!!e&&Array.isArray(e.groups)&&e.groups.length>0}function E(e){if(e===null)return[];try{const t=JSON.parse(e);return Array.isArray(t)?f(t):null}catch{return null}}function M(e,t){try{const n=E(e.getItem(A)),a=n||[];if(t===void 0)return{ids:a,ok:!0};const s=new Set(f(t)),r=a.filter(i=>s.has(i));return(!n||r.length!==a.length)&&e.setItem(A,JSON.stringify(r)),{ids:r,ok:!0}}catch{return{ids:[],ok:!1}}}function J(e,t){const n=f(t);try{return e.setItem(A,JSON.stringify(n)),{ids:n,ok:!0}}catch{return{ids:[],ok:!1}}}function K(e,t={}){if(!e)return null;const n=L(e);if(!N(n))return null;const a=f(t.liveSessionIds),s=f(t.openWebviewIds),r=new Set(a),i=new Set(s),d=new Set(C(t.collapsedGroupIds)),c=t.activeWebviewId?`webview:${t.activeWebviewId}`:t.activeSessionId?`session:${t.activeSessionId}`:"",p=o=>o.kind==="session"?r.has(o.id):i.has(o.id),u=new Set,l=[],y={},h={},I=[],_=(o,g,R)=>{const m=[],w=[];let D=0;for(const v of o){const b=$(v);if(u.has(b)||!p(v))continue;u.add(b),h[b]=g,D++;const x={kind:v.kind,id:v.id};if(R&&b!==c){y[b]=g,w.push(x);continue}m.push(x),l.push(x)}return{shown:m,hidden:w,count:D}};for(const o of n.groups){const g=d.has(o.id),{shown:R,hidden:m,count:w}=_(o.refs,o.id,g);I.push({id:o.id,name:o.name,refs:R,hidden:m,count:w,collapsed:g})}const q=[...a.map(o=>({kind:"session",id:o})),...s.map(o=>({kind:"webview",id:o}))],S=_([...n.ungrouped,...q],null,!1);return S.count>0&&I.push({id:null,name:"",refs:S.shown,hidden:[],count:S.count,collapsed:!1}),{sections:I,visibleRefs:l,hiddenTabGroupByRef:y,sectionByRef:h}}const k={action:2,idle:1};function W(e,t){const n={},a=e&&Array.isArray(e.sections)?e.sections:[];for(const s of a){if(s.id===null||!Array.isArray(s.hidden))continue;let r=null;for(const i of s.hidden){if(i.kind!=="session")continue;const d=t(i.id);k[d]&&(!r||k[d]>k[r])&&(r=d)}r&&(n[s.id]=r)}return n}function F(e,t,n){return t?JSON.stringify({collapsed:f(n).sort(),sections:t.sections.map(a=>[a.id,a.name,a.count,a.refs.map($),(a.hidden||[]).map($)])}):null}function B(e,t,n){return(e&&Array.isArray(e.sections)?e.sections:[]).map((s,r)=>{const i=s.refs.map(h=>t(h)).join("");if(s.id===null)return`<section class="tab-layout-group tab-layout-ungrouped" role="presentation" data-tab-group-id=""><div class="tab-layout-group-header tab-layout-ungrouped-header" aria-hidden="true"><span class="tab-layout-group-name">Ungrouped</span><span class="tab-layout-group-count">${s.count}</span></div><div class="tab-layout-group-refs" role="presentation">${i}</div></section>`;const d=n(s.id),c=`tab-layout-group-refs-${r}`,p=`tab-layout-group-name-${r}`,u=s.count===0,l=!s.collapsed&&!u,y=u?"":` aria-expanded="${l?"true":"false"}"`;return`<section class="tab-layout-group${s.collapsed?" tab-layout-group--collapsed":""}" role="presentation" data-tab-group-id="${d}"><div class="tab-layout-group-header tab-layout-group-toggle" role="treeitem" tabindex="-1" data-tab-group-header="${d}"${y}${l?` aria-owns="${c}"`:""} onclick="app.toggleTabGroupCollapsed(this.dataset.tabGroupHeader)"><span class="tab-layout-group-chevron" aria-hidden="true"></span><span class="tab-layout-group-name" id="${p}" data-i18n-skip>${n(s.name)}</span><span class="tab-layout-group-count">${s.count}</span></div><div class="tab-layout-group-refs" id="${c}" ${l?`role="group" aria-labelledby="${p}"`:'role="presentation"'}>${i}</div></section>`}).join("")}function P(e){const t=Number.isFinite(e.retryDelayMs)?e.retryDelayMs:5e3,n=Number.isFinite(e.maxRetryDelayMs)?e.maxRetryDelayMs:6e4,a=Number.isSafeInteger(e.maxRetries)?e.maxRetries:4;let s=0,r=!1,i=null,d=0;const c=()=>{i!==null&&e.cancelRetry&&e.cancelRetry(i),i=null},p=async()=>{if(r)return!1;const u=++s;c();try{const l=await e.fetchLayout();return r||u!==s?!1:(d=0,e.applyLayout(l),!0)}catch{if(r||u!==s)return!1;if(d++,e.applyFallback(),d<=a){const y=Math.min(n,t*2**(d-1));i=e.scheduleRetry(()=>p(),y)}return!1}};return{load:p,dispose(){r=!0,s++,c()}}}T.CodemanTabLayout={normalizeLayout:L,hasGroups:N,project:K,hiddenGroupAlerts:W,structureKey:F,renderProjection:B,createLoadCoordinator:P,loadCollapsedGroupIds:M,saveCollapsedGroupIds:J}})(typeof window<"u"?window:globalThis);

package/dist/web/public/terminal-split.js

@@ -14,6 +14,9 @@
  */
 
 (function (global) {
+  // How long a scroll-to-top history pull may hold Pane B's live output.
+  const HISTORY_PULL_TIMEOUT_MS = 10000;
+
   /**
    * Minimal chunked write for Pane B's own xterm instance — write() in
    * TERMINAL_CHUNK_SIZE slices, yielding a frame between each, instead of one
@@ -68,10 +71,21 @@
       this.fitAddon = null;
       this.ws = null;
       this._wsReady = false;
+      this._wsClosed = false;
       this._destroyed = false;
       // Single-flight state for _loadBuffer()/_refreshBuffer() below.
       this._bufferLoading = false;
       this._bufferRefreshPending = false;
+      // Scroll-to-top history pull (shell panes only), see _maybeLoadMoreHistory().
+      // `_liveQueue` is non-null from the pull's response until its finally
+      // block: live frames are held there with their arrival time instead of
+      // written under the replay. `_markerOwed` is the "disconnected" marker a
+      // load still has to write (see _onSocketClosed()/_stampMarkerIfOwed()).
+      this._historyPullAt = 0;
+      this._historyPullUseless = false;
+      this._liveQueue = null;
+      this._markerOwed = false;
+      this._onWheel = null;
     }
 
     async connect() {
@@ -95,6 +109,8 @@
       this.terminal.open(this.mountEl);
       this.fitAddon.fit();
 
+      this._installWheelListener();
+
       this.terminal.onData((data) => {
         if (this.ws && this.ws.readyState === WebSocket.OPEN) {
           this.ws.send(JSON.stringify({ t: 'i', d: data }));
@@ -156,14 +172,17 @@
         // session (this.sessionId), never the primary pane's
         // activeSessionId, and has no local-echo overlay of its own to flush
         // first (Pane B is deliberately plainer — see the fileoverview).
-        if (ev.key === 'Enter' && (ev.shiftKey || ev.ctrlKey) && ev.type === 'keydown') {
-          fetch(`/api/sessions/${this.sessionId}/send-key`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ key: ev.ctrlKey ? 'C-Enter' : 'S-Enter' }),
-          }).catch(() => {
-            /* Best-effort, matching this pane's tolerance elsewhere. */
-          });
+        // Swallow keypress/keyup too (xterm would send \r for a Shift-only keypress); only keydown sends.
+        if (ev.key === 'Enter' && (ev.shiftKey || ev.ctrlKey)) {
+          if (ev.type === 'keydown') {
+            fetch(`/api/sessions/${this.sessionId}/send-key`, {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ key: ev.ctrlKey ? 'C-Enter' : 'S-Enter' }),
+            }).catch(() => {
+              /* Best-effort, matching this pane's tolerance elsewhere. */
+            });
+          }
           return false;
         }
         // Smart copy (mirrors terminal-ui.js's Ctrl+C gate, #211): with a
@@ -254,9 +273,9 @@
         try {
           const msg = JSON.parse(event.data);
           if (msg.t === 'o') {
-            this.terminal.write(msg.d);
+            this._onLiveOutput(msg.d);
           } else if (msg.t === 'c') {
-            this.terminal.clear();
+            this._onLiveClear();
           } else if (msg.t === 'r') {
             // Server-triggered refresh (SSE backpressure cleared, terminal
             // data was dropped). The primary pane routes this to
@@ -280,16 +299,49 @@
       // normal while it quietly ate everything typed into it. v1 scope is
       // "say so", not reconnect — collapsing the split would lose the
       // user's place in Pane B's scrollback for a transient blip.
-      this.ws.onclose = () => {
-        this._wsReady = false;
-        this.terminal?.write('\r\n\x1b[2m[Pane B disconnected — close and reopen the split to reconnect]\x1b[0m\r\n');
-      };
+      this.ws.onclose = () => this._onSocketClosed();
 
       this.ws.onerror = () => {
         // onclose fires after onerror — cleanup happens there.
       };
     }
 
+    // The socket's close, split out of connect() so the tests can drive it.
+    // While any load runs (a history pull or a `{t:'r'}` refresh) the marker is
+    // only owed, and that load's finally block settles it (_stampMarkerIfOwed()):
+    // written now, it would sit above the output a pull is still holding (flushed
+    // after it on a skip, a downgrade or a failed fetch), above a refresh's
+    // replay, or in the middle of a chunked replay. A pull still waiting for its
+    // response holds the marker too, for as long as the request takes (up to its
+    // budget, see _pullHistory()).
+    _onSocketClosed() {
+      this._wsReady = false;
+      this._wsClosed = true;
+      if (this._bufferLoading) this._markerOwed = true;
+      else this._writeDisconnectedMarker();
+    }
+
+    // Settles a marker the pane owes: set when a close lands during a load (the
+    // replay would otherwise sit below it) or when a load wipes the terminal on
+    // a closed socket. Called from each load's own finally, just before
+    // _endBufferLoad() starts any trailing refresh.
+    _stampMarkerIfOwed() {
+      // A trailing refresh is about to clear() synchronously, while xterm parses
+      // a write() on a later tick: a marker written here would land in the
+      // freshly cleared buffer ABOVE that refresh's replay, a second, stale copy.
+      // The refresh re-owes the marker on a closed socket and stamps it itself.
+      if (this._bufferRefreshPending && !this._destroyed) return;
+      const owed = this._markerOwed;
+      this._markerOwed = false;
+      if (owed && this._wsClosed && !this._destroyed) this._writeDisconnectedMarker();
+    }
+
+    // Extracted so both _onSocketClosed() and a load that ends owing it on a
+    // closed socket can write it (see _stampMarkerIfOwed()).
+    _writeDisconnectedMarker() {
+      this.terminal?.write('\r\n\x1b[2m[Pane B disconnected — close and reopen the split to reconnect]\x1b[0m\r\n');
+    }
+
     // Fetches and writes the session's current scrollback. Used both by
     // connect() (initial load) and by the `{t:'r'}` server-refresh frame
     // (below) — the primary pane's own _onSessionNeedsRefresh (app.js) is
@@ -324,14 +376,187 @@
       } catch {
         /* Best-effort — live output still arrives once the socket connects. */
       } finally {
-        this._bufferLoading = false;
+        this._stampMarkerIfOwed();
+        this._endBufferLoad();
       }
+    }
+
+    // Ends a single-flight load (initial, refresh or history pull): clears the
+    // flag, then runs the ONE trailing refresh that arrived while it was busy.
+    _endBufferLoad() {
+      this._bufferLoading = false;
       if (this._bufferRefreshPending && !this._destroyed) {
         this._bufferRefreshPending = false;
         this._refreshBuffer();
       }
     }
 
+    // Live terminal output. Written straight through, except while a history
+    // pull is replaying: a capture is current only up to the instant tmux took
+    // it, so a frame arriving mid-replay is held with its arrival time and
+    // replayed behind the snapshot by _pullHistory() (the primary pane's
+    // _finishBufferLoad `since` rule), never written underneath it.
+    _onLiveOutput(data) {
+      if (this._liveQueue) this._liveQueue.push({ at: performance.now(), data });
+      else this.terminal?.write(data);
+    }
+
+    // The server's `{t:'c'}` clear frame takes the same route as output, for the
+    // same reason: clearing straight away, mid-replay, would wipe the half-written
+    // snapshot and leave _pullHistory() measuring a buffer that is no longer the
+    // one it is restoring. Queued, it lands in order with the frames around it.
+    _onLiveClear() {
+      if (this._liveQueue) this._liveQueue.push({ at: performance.now(), clear: true });
+      else this.terminal?.clear();
+    }
+
+    // Capture phase, because xterm's own wheel handler stopPropagation()s every
+    // event it consumes, so a bubbling listener here would never see the wheel
+    // while the pane still has scrollback to scroll. Passive: this only observes,
+    // xterm keeps doing the scrolling.
+    _installWheelListener() {
+      this._onWheel = (ev) => {
+        if (ev.deltaY < 0) this._maybeLoadMoreHistory();
+      };
+      this.mountEl.addEventListener('wheel', this._onWheel, { capture: true, passive: true });
+    }
+
+    // Wheel-up at the top of a SHELL pane's scrollback. tmux repaints a burst of
+    // output (`cat` of a file longer than the screen) instead of scrolling it,
+    // so this pane's xterm ends up with about one screen of scrollback while
+    // tmux holds every line — and nothing here ever went back to ask, so the
+    // history was unreachable. The primary pane has the same pull
+    // (app.js _maybeRefetchFullHistory); Pane B is a separate xterm and needs its
+    // own. Shell only: a non-shell CLI's history is out of scope for this pull
+    // (its load already takes `full=1`; codex and Claude's inline renderer do
+    // grow tmux history, this just isn't how they recover it). The alternate-
+    // screen skip (nano, vim, less) only matters for a direct-PTY shell — under
+    // tmux the browser xterm never enters the alternate buffer.
+    _maybeLoadMoreHistory() {
+      if (this.sessionMode !== 'shell' || this._destroyed || !this.terminal) return;
+      if (this._bufferLoading) return;
+      // Mirrors app.js _maybeRefetchFullHistory and this pane's own
+      // _sendResize(): a detached session's own window already owns its PTY
+      // size and scrollback, so Pane B has nothing of its own to reconcile.
+      if (this.detachedSessions?.has(this.sessionId)) return;
+      const active = this.terminal.buffer.active;
+      if (active.type !== 'normal' || active.viewportY !== 0) return;
+      // Momentum scrolling fires this dozens of times per flick, so cooldown
+      // rather than latch; a pull that could only have downgraded the pane
+      // waits far longer.
+      const cooldown = this._historyPullUseless ? 60000 : 4000;
+      const now = Date.now();
+      if (now - this._historyPullAt < cooldown) return;
+      this._historyPullAt = now;
+      void this._pullHistory();
+    }
+
+    // Pulls a BOUNDED window of tmux's full history (the same TERMINAL_TAIL_SIZE
+    // a tab switch loads, so a multi-megabyte capture never lands on xterm's
+    // main thread) and replays it under the reader's current place. Holds the
+    // single-flight flag across the fetch AND the replay, like _loadBuffer().
+    async _pullHistory() {
+      this._bufferLoading = true;
+      let replayed = false;
+      let capturedAt = 0;
+      // Two budgets on one signal. The request itself gets the primary pane's
+      // (CodemanFetchDeadline, constants.js): live output is not held while it
+      // runs, but the single-flight flag is, so a coalesced `{t:'r'}` refresh and
+      // the marker owed by a close (_onSocketClosed()) both wait for it, at worst
+      // for that whole budget. Once the headers land live output IS held, so the
+      // body read gets the short one instead: a body that hangs would otherwise
+      // freeze the pane for the long budget. Aborting lands in the catch below,
+      // which releases the flag and the queue. AbortSignal.timeout() alone cannot
+      // be re-armed, hence the controller; without AbortController the pull
+      // simply has no deadline.
+      const controller = global.AbortController ? new global.AbortController() : null;
+      let abortTimer = null;
+      const armDeadline = (ms) => {
+        if (!controller) return;
+        clearTimeout(abortTimer);
+        abortTimer = setTimeout(() => controller.abort(), ms);
+      };
+      try {
+        armDeadline(global.CodemanFetchDeadline?.terminalFetchDeadlineMs?.({ full: true }) ?? HISTORY_PULL_TIMEOUT_MS);
+        const res = await fetch(`/api/sessions/${this.sessionId}/terminal?full=1&tail=${TERMINAL_TAIL_SIZE}`, {
+          signal: controller?.signal,
+        });
+        armDeadline(HISTORY_PULL_TIMEOUT_MS);
+        // The cutoff below is the response's arrival, the same `since` rule the
+        // primary pane uses (_finishBufferLoad). It is a client clock standing in
+        // for the instant tmux took the capture, which lies somewhere in the
+        // round trip, so a frame in that window can be lost or doubled. Bounded
+        // by one round trip and not closable without a server-side capture time.
+        capturedAt = performance.now();
+        // Opened only now: a frame from before the response is either replaced by
+        // the capture or written unchanged, so holding it for the round trip
+        // bought nothing and froze the pane for as long as the fetch took.
+        this._liveQueue = [];
+        const payload = (await res.json())?.data;
+        clearTimeout(abortTimer);
+        const buffer = payload?.terminalBuffer;
+        const term = this.terminal;
+        if (!buffer || !term || this._destroyed) return;
+        const rowsBefore = term.buffer.active.length;
+        const rowsIncoming = global.app?._estimateReplayRows?.(buffer, term.cols) ?? buffer.split('\n').length;
+        // xterm keeps at most `scrollback + rows` rows while tmux keeps far more
+        // lines, so a window of short lines can carry more rows than this pane
+        // can ever hold, and `rowsIncoming <= rowsBefore` would never come true.
+        const scrollbackCap = term.options?.scrollback || 0;
+        const paneFull = scrollbackCap > 0 && rowsBefore >= scrollbackCap + term.rows;
+        // Nothing to gain (this also covers a downgrade, which would delete
+        // history mid-scroll), and a reset+rewrite would jump the viewport. An
+        // untruncated window IS all of tmux's history and the next burst can add
+        // more, so keep the 4 s cooldown. A truncated window can never reach past
+        // what the pane shows, and every ask costs the server a capture-pane of
+        // the whole history (`tail` is cut after it): back off to 60 s, as the
+        // primary pane does (app.js _maybeRefetchFullHistory). A full pane backs
+        // off too, since no window can ever fit in it.
+        if (rowsIncoming <= rowsBefore || paneFull) {
+          if (payload.truncated || paneFull) this._historyPullUseless = true;
+          return;
+        }
+        this._historyPullUseless = false;
+        term.write('\x1bc');
+        replayed = true;
+        if (this._wsClosed) this._markerOwed = true;
+        await writeChunked(term, buffer, () => this._destroyed);
+        if (this._destroyed || !this.terminal) return;
+        // xterm parses asynchronously: an empty write's callback fires only
+        // after everything before it, so the row count below is the settled one.
+        await new Promise((resolve) => this.terminal.write('', resolve));
+        if (this._destroyed || !this.terminal) return;
+        // The replay grew the buffer UPWARD, so what was row 0 is now `delta`
+        // rows down; land there and the recovered history sits above it.
+        const delta = this.terminal.buffer.active.length - rowsBefore;
+        if (delta > 0) this.terminal.scrollToLine(delta);
+        else this.terminal.scrollToTop();
+      } catch {
+        /* Best-effort — live output keeps arriving whatever happens here. */
+      } finally {
+        clearTimeout(abortTimer);
+        const queued = this._liveQueue ?? [];
+        this._liveQueue = null;
+        // After a replay, only frames that arrived after the capture are news;
+        // earlier ones are already in it. With no replay, every held frame is.
+        const cutoff = replayed ? capturedAt : 0;
+        for (const entry of queued) {
+          if (entry.at < cutoff) continue;
+          if (entry.clear) this.terminal?.clear();
+          else this.terminal?.write(entry.data);
+        }
+        // Settled after the queue flush so the marker is the last thing on
+        // screen: a close during the pull wrote nothing (_onSocketClosed() defers
+        // it while a load runs), and a replay's own `\x1bc` (flagged above) wipes
+        // one written before it, which would paint a fresh, current-looking
+        // history while onData keeps silently dropping every keystroke on the
+        // dead socket. With a trailing refresh pending (_endBufferLoad) the marker
+        // is left to that refresh, which writes it below its own replay.
+        this._stampMarkerIfOwed();
+        this._endBufferLoad();
+      }
+    }
+
     // The `{t:'r'}` server-refresh path: clear, then replay. Two refresh
     // frames in a row used to start two concurrent replays, each clearing
     // the terminal under the other's chunked write. A refresh that arrives
@@ -344,6 +569,10 @@
         return;
       }
       this.terminal?.clear();
+      // The clear wipes a "disconnected" marker (a `{t:'r'}` frame can queue a
+      // trailing refresh behind a pull that the socket's close then interrupts),
+      // so a refresh on a closed socket owes it back once its replay is written.
+      if (this._wsClosed) this._markerOwed = true;
       void this._loadBuffer();
     }
 
@@ -381,6 +610,10 @@
 
     destroy() {
       this._destroyed = true;
+      if (this._onWheel) {
+        this.mountEl?.removeEventListener('wheel', this._onWheel, { capture: true });
+        this._onWheel = null;
+      }
       if (this.ws) {
         this.ws.onopen = null;
         this.ws.onmessage = null;