@agfpd/iapeer 0.2.70 → 0.2.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "type": "module",
   "bin": {

package/src/supervisor/daemon.test.ts

@@ -174,4 +174,40 @@ d('supervisor daemon (Bun-native pty, tick runtime)', () => {
       }
     }
   })
+
+  // FINDING-2 — restore the SERVE geometry on last detach. The daemon resizes the child pty to a
+  // client's size on attach and (before this) never restored it, so an unattached session stuck at a
+  // departed client's size → the fixed-geometry warm-deliver/ready-gate viewport model mismatched the
+  // pty. Drive it with a child that prints its live pty winsize ("ROWS COLS") to the pane-log: attach
+  // small → pty shrinks; detach → pty restores to the serve geometry.
+  test('FINDING-2: last detach restores the serve geometry (no sticking at the client size)', async () => {
+    const gSession = 'ptsgeo'
+    const paneLog = join(runDir, 'geo-pane.log')
+    const lastSize = (): string => {
+      const t = existsSync(paneLog) ? readFileSync(paneLog, 'utf8') : ''
+      const m = [...t.matchAll(/(\d+) (\d+)/g)]
+      return m.length ? `${m[m.length - 1][1]}x${m[m.length - 1][2]}` : ''
+    }
+    try {
+      const r = startSupervisorDaemon({
+        session: gSession,
+        runtime: 'tick',
+        runDir,
+        // serve geometry 200x50 (distinct from defaults); child reports its live pty winsize as "rows cols"
+        serve: { argv: ['sh', '-c', 'while :; do stty size 2>/dev/null; sleep 0.3; done'], env: { PATH: process.env.PATH ?? '' }, cwd: runDir, paneLogPath: paneLog, cols: 200, rows: 50 },
+      })
+      expect(r.state).toBe('started')
+      expect(await waitFor(() => lastSize() === '50 200'.replace(' ', 'x'), 6000)).toBe(true) // at serve geometry
+      const c = await attach(runDir, gSession, 90, 30) // attach at a DIFFERENT size → pty resizes to it
+      expect(await waitFor(() => lastSize() === '30x90', 6000)).toBe(true) // pty shrank to the client size
+      c.close() // last client gone
+      expect(await waitFor(() => lastSize() === '50x200', 6000)).toBe(true) // RESTORED to serve geometry
+    } finally {
+      try {
+        killSession(runDir, gSession)
+      } catch {
+        /* */
+      }
+    }
+  })
 })

package/src/supervisor/daemon.ts

@@ -90,6 +90,13 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   const { session, runtime, runDir } = opts
   let cols = opts.cols ?? 80
   let rows = opts.rows ?? 30
+  // The SERVE geometry — the size the session is hosted at (HOST_COLS×HOST_ROWS for a pty-host peer),
+  // immutable. `cols`/`rows` above track the CURRENT (client-driven) size. A client attaches at its own
+  // terminal size and the pty resizes to match; on LAST detach we restore the serve geometry (below) so
+  // the unattached session never sticks at a departed client's size — otherwise the warm-deliver /
+  // ready-gate viewport model (built at the fixed serve geometry) mismatches the actually-resized pty.
+  const serveCols = cols
+  const serveRows = rows
   const sock = sockPath(runDir, session)
   const pid = pidPath(runDir, session)
 
@@ -217,28 +224,40 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
     sendClient(s, frame(FRAME_DATA, Buffer.from(snap, 'utf8')))
   }
 
+  // Resize the model + child pty to (c, r). Shared by client FRAME_RESIZE and the last-detach restore.
+  const applyGeometry = (c: number, r: number): void => {
+    cols = c
+    rows = r
+    try {
+      xterm.resize(c, r)
+      child.terminal.resize(c, r)
+    } catch {
+      /* transient */
+    }
+    // Best-effort SIGWINCH nudge for a SIGWINCH-reactive child (forces a repaint at the new size); NOT
+    // load-bearing for an attached client (the complete snapshot repaint is), but for the unattached
+    // restore it is what makes the child redraw into the pane-log at the serve geometry.
+    try {
+      child.terminal.resize(c, Math.max(1, r - 1))
+      child.terminal.resize(c, r)
+    } catch {
+      /* */
+    }
+  }
+  // Restore the serve geometry when the last client detaches, so the unattached session never sticks at
+  // a departed client's size (FINDING-2 — would mismatch the fixed-geometry warm-deliver/ready-gate
+  // viewport model). No-op when already at serve geometry or a client is still attached.
+  const restoreServeGeometryIfIdle = (): void => {
+    if (clients.size === 0 && (cols !== serveCols || rows !== serveRows)) applyGeometry(serveCols, serveRows)
+  }
+
   const onClientFrame = (s: { write(b: Buffer): number }, type: number, payload: Buffer): void => {
     if (type === FRAME_DATA) {
       child.terminal.write(payload) // keystrokes → child
     } else if (type === FRAME_RESIZE) {
       const sz = parseSize(payload)
-      cols = sz.cols
-      rows = sz.rows
-      try {
-        xterm.resize(cols, rows)
-        child.terminal.resize(cols, rows)
-      } catch {
-        /* transient */
-      }
+      applyGeometry(sz.cols, sz.rows)
       repaint(s) // instant paint from the snapshot (delivered COMPLETE via backpressure)
-      // Best-effort SIGWINCH nudge for a SIGWINCH-reactive child; NOT load-bearing (the complete
-      // snapshot above is the real freshness fix).
-      try {
-        child.terminal.resize(cols, Math.max(1, rows - 1))
-        child.terminal.resize(cols, rows)
-      } catch {
-        /* */
-      }
     }
   }
 
@@ -266,11 +285,13 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
         clients.delete(s)
         writers.delete(s)
         syncAttached()
+        restoreServeGeometryIfIdle() // last client gone → un-stick the pty from its size
       },
       error(s: object) {
         clients.delete(s)
         writers.delete(s)
         syncAttached()
+        restoreServeGeometryIfIdle()
       },
     },
   })