@agfpd/iapeer 0.2.82 → 0.2.84

package/package.json

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

package/src/lifecycle/index.ts

@@ -592,7 +592,7 @@ export function resolveWakeMode(
       : { resume: false, cause: 'idle-reaped-human-no-resume' }
   }
   // executor: RESUME is an INTENTIONAL "continue THIS work" signal — it happens ONLY when
-  // the incoming message carries a topic that matches the session's last topic. A DIFFERENT
+  // the incoming message carries a topic that matches the session's topic set. A DIFFERENT
   // topic (new work) OR NO topic at all → FRESH. Rationale: a topicless ping after an idle
   // gap is not a request to resume specific work; defaulting it to resume revived stale
   // context (e.g. a 3-day-old session). The sender opts INTO continuity by passing the topic.
@@ -1160,11 +1160,19 @@ export interface SuperviseOutcome {
 export interface SuperviseDeps {
   env?: NodeJS.ProcessEnv
   nowMs?: number
+  /** Activity proxy seam (default: the runtime adapter's transcript/session mtime). Tests inject a
+   *  controlled value to exercise the idle-age floor without a real transcript on disk. */
+  newestActivityMtime?: (runtime: string, cwd: string) => number | null
+  /** Liveness seam (default: the real `sessionAlive` = pty-host OR tmux-fallback). Tests inject a
+   *  fixed verdict so the idle path is exercised hermetically — no live tmux/pty session needed. */
+  sessionAlive?: (sock: string, identity: string) => boolean
 }
 
 export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): SuperviseOutcome[] {
   const env = deps.env ?? process.env
   const nowMs = deps.nowMs ?? Date.now()
+  const activityMtime = deps.newestActivityMtime ?? ((rt: string, c: string) => getAdapter(rt as Runtime).newestActivityMtime(c))
+  const isAlive = deps.sessionAlive ?? sessionAlive
   const verbose = superviseLogVerbose(env)
   // tmux command-log volume cap (killer-hunt socket-command layer, launch/cmdlog.ts):
   // a -v server log under a busy TUI grows ~7 KB/s, so each tick tail-keeps any log
@@ -1186,7 +1194,7 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
       continue
     }
     const sock = buildSocketPath(s.runtime, s.personality, cfg.sockDir)
-    if (!sessionAlive(sock, s.identity)) {
+    if (!isAlive(sock, s.identity)) {
       // A DELIBERATE stop is not a death: the stop verb parks clean
       // (.stopped + .idle-reaped) and kills the session itself. Catch-up branch for
       // a stop that raced this tick (or a pre-fix stop): drop the state quietly —
@@ -1235,14 +1243,19 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
       continue
     }
     // Idle accounting via the runtime adapter's activity proxy (claude transcript
-    // / codex session mtime); fall back to wokeAt so a session that produced zero
-    // further turns is still reaped, and when no adapter exists yet (codex/telegram
-    // pre-workflow-#2 — session-states are claude-only for now anyway).
+    // / codex session mtime), FLOORED at wokeAt: a session cannot be idle longer than
+    // it has been awake. A wake that produced no model turn (e.g. an attach-only resume)
+    // leaves the proxy at its PRE-wake value; the old `?? wokeAt` floored only the NULL
+    // case, so a stale-but-non-null proxy (older than this wake) made a freshly-woken
+    // session look idle for its entire prior life → idle-reaped on the very next tick,
+    // out from under an attaching operator. max(), not ??, is the fix — and it still
+    // reaps a session that produced zero further turns (mt=wokeAt → reaped idleSecs
+    // after the wake), and falls back to wokeAt when no adapter exists for the runtime.
     let mt = s.wokeAt
     try {
-      mt = getAdapter(s.runtime).newestActivityMtime(s.cwd) ?? s.wokeAt
+      mt = Math.max(activityMtime(s.runtime, s.cwd) ?? 0, s.wokeAt)
     } catch {
-      /* no adapter for this runtime yet → wokeAt fallback */
+      /* no adapter for this runtime yet → wokeAt baseline */
     }
     const ageSecs = Math.floor((nowMs - mt) / 1000)
     // wake_policy:ephemeral M2 — die-after-reply: an ARMED ephemeral session (the

package/src/supervisor/daemon.ts

@@ -163,6 +163,12 @@ 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.
+  const painted = new WeakSet<object>()
   // 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
@@ -253,6 +259,16 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): 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')))
+  }
 
   // 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 => {
@@ -287,7 +303,12 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
     } else if (type === FRAME_RESIZE) {
       const sz = parseSize(payload)
       applyGeometry(sz.cols, sz.rows)
-      repaint(s) // instant paint from the snapshot (delivered COMPLETE via backpressure)
+      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)
+      }
     }
   }
 
@@ -303,7 +324,11 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
         framers.set(s as object, makeFramer((t, p) => onClientFrame(s, t, p)))
         clients.add(s)
         syncAttached() // ≥1 client now attached → marker present
-        repaint(s) // UNCONDITIONAL repaint on attach (tmux-like)
+        // NO repaint here. A viewer's runClient sends its real terminal size as the FIRST FRAME_RESIZE on
+        // connect (client.ts open → "repaint at our size"); we paint THEN, ONCE, at the correct geometry.
+        // Painting here at the serve geometry (e.g. 220×50) would send a second, wrong-width dump that
+        // STACKS in a terminal ignoring \x1b[3J (Apple Terminal) → smeared scroll-up history (Bug B). A
+        // deliver client (deliverToHost) never resizes and ignores output → it gets no wasted paint.
       },
       data(s: object, d: Uint8Array) {
         framers.get(s)?.(d)

package/src/transport/index.ts

@@ -494,7 +494,7 @@ export function deliverViaTmux(target: DeliveryTarget, envelope: string, cwd?: s
     } while (monotonicMs() < graceDeadline)
     return err(
       `peer "${target.personality}" (${target.runtime}) is listed live but did not accept the message ` +
-        `(no input-clear, no transcript advance within ${livenessGraceMs()}ms) — treated as dead; message NOT delivered`,
+        `(no input-clear, no transcript advance within ${livenessGraceMs()}ms) — live but unresponsive to this delivery (not dead); message NOT delivered`,
     )
   }
   sleepSync(PASTE_SETTLE_MS)
@@ -579,7 +579,7 @@ async function deliverViaHost(
   } while (monotonicMs() < graceDeadline)
   return err(
     `hosted peer "${target.personality}" (${target.runtime}) is listed live but did not accept the message ` +
-      `(no transcript advance within ${graceMs}ms) — treated as dead; message NOT delivered`,
+      `(no transcript advance within ${graceMs}ms) — live but unresponsive to this delivery (not dead); message NOT delivered`,
   )
 }