@agfpd/iapeer 0.2.84 → 0.2.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.84",
+  "version": "0.2.86",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/supervisor/daemon.ts

@@ -5,11 +5,11 @@
 // detached process, dynamic-imported from the launch path (supervisor/index.ts → daemon.ts), so
 // @xterm never loads in the central router's delivery path nor in the launch/lifecycle process.
 //
-// Loads @xterm/headless + @xterm/addon-serialize (the latter is the repaint source: a reattaching
-// client gets the full current screen even if the child is silent). Both bundle under
+// Loads @xterm/headless as the authoritative model (boot-driver reads it; capability queries answered
+// off it). The attach catch-up is NOT a model serialize — it REPLAYS the child's recent raw output ring
+// (claude's own bytes → native scrollback, no duplication; see repaint). @xterm/headless bundles under
 // `bun build --compile` (pure JS; the Bun-native pty has no native addon).
 import { Terminal } from '@xterm/headless'
-import { SerializeAddon } from '@xterm/addon-serialize'
 import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, unlinkSync, writeFileSync, writeSync } from 'node:fs'
 import { dirname } from 'node:path'
 import {
@@ -131,8 +131,6 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   const pid = pidPath(runDir, session)
 
   const xterm = new Terminal({ cols, rows, allowProposedApi: true, scrollback: 5000 })
-  const ser = new SerializeAddon()
-  xterm.loadAddon(ser)
 
   const bin = opts.bin ?? knownLauncher(runtime) ?? runtime
   // SERVING SEAM (slice b): opts.argv (launch-composed, carries the system-prompt swap + PEER_START_ARGS)
@@ -163,12 +161,28 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   const clients = new Set<unknown>()
   const writers = new WeakMap<object, BackpressureWriter>()
   const framers = new WeakMap<object, (chunk: Uint8Array) => void>()
-  // FIRST-PAINT TRACKING (Bug B fix): a client gets the full scrollback dump EXACTLY ONCE — on its first
-  // FRAME_RESIZE (which runClient always sends on connect, at the real terminal size). Re-dumping
-  // scrollback on every attach/resize STACKS duplicate histories in a terminal that ignores \x1b[3J
-  // (Apple Terminal has NO E3 capability) → smeared/overlapping scroll-up history. Subsequent resizes
-  // refresh the VIEWPORT only (repaintViewport), never the scrollback.
+  // FIRST-PAINT TRACKING (Bug B fix): a client gets the full scrollback catch-up EXACTLY ONCE — on its
+  // first FRAME_RESIZE (which runClient always sends on connect, at the real terminal size). Re-dumping
+  // on a later resize STACKS duplicate histories in a terminal that ignores \x1b[3J (Apple Terminal has
+  // NO E3 capability) → smeared/overlapping scroll-up history. After the catch-up the supervisor does
+  // NOTHING on resize — the child redraws its viewport (SIGWINCH) and the terminal reflows its own
+  // scrollback, like a directly-launched claude.
   const painted = new WeakSet<object>()
+  // RAW REPLAY RING (Bug B catch-up): the last ~RAW_RING_MAX bytes of the child's RAW output, exactly as
+  // forwarded to live clients. The attach catch-up REPLAYS this verbatim so the client renders claude's
+  // OWN bytes — native scrollback, NO duplication. (The previous catch-up dumped the @xterm model via
+  // SerializeAddon, which captures claude's no-scroll-region status/tool-list redraws as DUPLICATE
+  // scrollback frames; a directly-launched claude has no such duplication — the dup was the model's, not
+  // claude's.) No clears in the replay: Apple Terminal scrolls \x1b[2J into scrollback and ignores
+  // \x1b[3J, so claude's own print+\n stream is the only clean primitive.
+  const RAW_RING_MAX = 1024 * 1024
+  const rawRing: Buffer[] = []
+  let rawRingBytes = 0
+  const ringAppend = (b: Buffer): void => {
+    rawRing.push(b)
+    rawRingBytes += b.length
+    while (rawRingBytes > RAW_RING_MAX && rawRing.length > 1) rawRingBytes -= rawRing.shift()!.length
+  }
   // ATTACHED-CLIENT MARKER (spawn-flip Ф0b-3 slice 3c): keep `<runDir>/<session>.attached` in sync with
   // clients.size — present iff ≥1 operator is attached. The warm-deliver path (a DIFFERENT process)
   // reads it to gate the hosted busy-composer hold: hold ONLY when a human is attached (their unfinished
@@ -225,7 +239,10 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
         xterm.write(buf) // authoritative model
         for (const r of capabilityResponses(s)) child.terminal.write(r) // answer capability queries
         const fwd = Buffer.from(stripQueries(s), 'latin1') // forward to clients sans queries (daemon is authoritative)
-        if (fwd.length) for (const c of [...clients]) sendClient(c as { write(b: Buffer): number }, frame(FRAME_DATA, fwd))
+        if (fwd.length) {
+          ringAppend(fwd) // keep recent raw output for the attach catch-up (raw replay = native, no dup)
+          for (const c of [...clients]) sendClient(c as { write(b: Buffer): number }, frame(FRAME_DATA, fwd))
+        }
       },
       exit(_t?: unknown, exitCode?: number | null, signalCode?: number | null) {
         // resilience-b exit-cause (spawn-flip Ф0b): record WHY the hosted child died into exits.log,
@@ -253,21 +270,22 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   } as unknown as Parameters<typeof Bun.spawn>[1]) as unknown as PtyChild
   xterm.onData(resp => child.terminal.write(resp)) // @xterm auto-answers DA1/DSR → back to child
 
-  /** Repaint a (re)attaching client from the headless snapshot: clear+home, then the full grid.
-   *  Backpressure-safe — a ~90 KB heavy snapshot MUST NOT drop past the socket buffer (port-dep #2). */
+  /** Catch up a (re)attaching client to the current screen + history ONCE by REPLAYING the child's recent
+   *  RAW output (its own bytes from the ring) — so the client renders exactly what a directly-launched
+   *  claude would, with native scrollback and NO duplication. Backpressure-safe — a ~1 MB replay MUST NOT
+   *  drop past the socket buffer (port-dep #2). Called EXACTLY ONCE per client (its first FRAME_RESIZE):
+   *  re-replaying on a later resize would stack a second history copy in a terminal that ignores \x1b[3J
+   *  (Apple Terminal has no E3) → smeared scroll-up history (Bug B). After the catch-up the supervisor
+   *  stops intervening: a resize just re-sizes the child (applyGeometry → SIGWINCH), and the child redraws
+   *  its own viewport while the terminal reflows its own scrollback — exactly like a direct claude launch.
+   *  NO clears (\x1b[2J/3J): Apple Terminal scrolls 2J into scrollback and ignores 3J — claude's own
+   *  print+\n stream is the only clean primitive. A leading \x1b[0m resets any inherited SGR before the
+   *  replay; the child's SIGWINCH redraw (from applyGeometry) then settles the current screen at the
+   *  client's width. Empty ring (fresh session, no output yet) → nothing to replay; the SIGWINCH redraw
+   *  paints the first screen. */
   const repaint = (s: { write(b: Buffer): number }): void => {
-    const snap = '\x1b[2J\x1b[3J\x1b[H' + stripSpinnerScrollback(ser.serialize(), xterm.rows)
-    sendClient(s, frame(FRAME_DATA, Buffer.from(snap, 'utf8')))
-  }
-  /** Refresh ONLY the visible viewport (current screen), never the scrollback — for a resize AFTER the
-   *  first full paint. `\x1b[2J\x1b[H` clears the screen and homes WITHOUT touching scrollback (no
-   *  \x1b[3J), then we write exactly the viewport rows (no scrollback segments), so nothing scrolls into
-   *  the client's native scrollback. This is what keeps a mid-session resize from stacking another
-   *  history copy in a terminal that ignores \x1b[3J (Bug B). */
-  const repaintViewport = (s: { write(b: Buffer): number }): void => {
-    const lines = ser.serialize().split('\r\n')
-    const viewport = lines.slice(Math.max(0, lines.length - xterm.rows)).join('\r\n')
-    sendClient(s, frame(FRAME_DATA, Buffer.from('\x1b[2J\x1b[H' + viewport, 'utf8')))
+    if (rawRingBytes === 0) return
+    sendClient(s, frame(FRAME_DATA, Buffer.concat([Buffer.from('\x1b[0m', 'latin1'), ...rawRing])))
   }
 
   // Resize the model + child pty to (c, r). Shared by client FRAME_RESIZE and the last-detach restore.
@@ -305,10 +323,11 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
       applyGeometry(sz.cols, sz.rows)
       if (!painted.has(s as object)) {
         painted.add(s as object)
-        repaint(s) // FIRST paint for this client: full snapshot (scrollback + viewport) at its real size
-      } else {
-        repaintViewport(s) // later resize: refresh the screen only — never re-dump scrollback (anti-stack)
+        repaint(s) // FIRST resize for this client = the one-time catch-up (full snapshot at its real size)
       }
+      // LATER resizes: nothing from the supervisor. applyGeometry already SIGWINCH'd the child → it
+      // redraws its own viewport (forwarded live) and the terminal reflows its own scrollback, exactly
+      // like a directly-launched claude. Re-dumping here would stack history in a no-\x1b[3J terminal.
     }
   }