@agfpd/iapeer 0.4.59 → 0.4.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.59",
+  "version": "0.4.61",
   "description": "Run Claude Code and Codex CLI as local background agents that message each other, wake on demand, and share one memory.",
   "license": "Apache-2.0",
   "author": "agfpd",

package/src/daemon/main.ts

@@ -39,6 +39,7 @@ import {
   addTopic,
   loadLifecycleConfig,
   processEagerRelaunches,
+  processOrphanEagerMarks,
   readTopic,
   resolveWakeRuntime,
   setEphemeralArmed,
@@ -373,6 +374,10 @@ export async function startConfiguredDaemon(opts: ConfiguredDaemonOptions = {}):
       tick: async () => {
         const outcomes = superviseTick(cfg, { env })
         await processEagerRelaunches(cfg, outcomes, { env })
+        // Orphaned-eager fallback: a .new-eager whose session died WITHOUT a .session
+        // on disk is invisible to superviseTick — relaunch it fresh here (H4-guarded;
+        // live incident 03.07: a self-fresh peer lay down until the owner attached).
+        await processOrphanEagerMarks(cfg, { env })
         // M3 drain scan — ONE mechanism for the whole serial-queue loop: feeds the
         // next task right after a reaped-ephemeral (same tick), drains on daemon
         // start (durable queue), and RETRIES a failed wake (the item stayed at the

package/src/lifecycle/index.ts

@@ -622,9 +622,26 @@ export function resolveWakeMode(
   resolveResume: (cwd: string) => { ok: boolean; ref?: string; reason?: string },
   incomingTopic?: string,
 ): WakeMode {
-  // 1. folder-launch → always fresh.
-  if (argsResume === false) return { resume: false, cause: 'folder-launch' }
-  // 2. attach → always resume, fail-loud if nothing to resume.
+  // 1. folder-launch → always fresh. Consume a standing .new-eager too — the mark's
+  // promise ("next bring-up is FRESH") is fulfilled by this launch; leaving it would
+  // leak an eager relaunch into a LATER, unrelated death.
+  if (argsResume === false) {
+    clearNewEager(cfg, identity)
+    return { resume: false, cause: 'folder-launch' }
+  }
+  // 1.5 — a standing .new-eager OUTRANKS EVERYTHING below, including attach-resume
+  // (live incident 03.07: a peer self-freshed, its eager relaunch never fired — the
+  // dead session carried no .session so the tick never saw it — and the owner's
+  // `iapeer list`→Enter attach then RESUMED the old context, defeating the self-fresh
+  // entirely). The mark is the owner's explicit "come up FRESH next"; ANY wake that
+  // finds it must honor it. Consume-on-fire + clear .idle-reaped (mirror .fresh-next
+  // hygiene: a stale clean-park marker must not make a later crash read as resume).
+  if (hasNewEager(cfg, identity)) {
+    clearNewEager(cfg, identity)
+    clearIdleReaped(cfg, identity)
+    return { resume: false, cause: 'self-fresh-eager' }
+  }
+  // 2. attach → resume, fail-loud if nothing to resume.
   if (argsResume === true) {
     const r = resolveResume(cwd)
     if (!r.ok) return { resume: false, failReason: r.reason ?? 'resume requested but nothing to resume', cause: 'attach-nothing-to-resume' }
@@ -1523,6 +1540,57 @@ export async function processEagerRelaunches(
   return results
 }
 
+/**
+ * ORPHANED eager-mark fallback (live incident 03.07, iapeer-memory): the standard eager
+ * path runs off superviseTick's `.session` walk — a peer whose session died WITHOUT a
+ * `.session` on disk (an unsupervised live session: a lost/never-written state file —
+ * the code even warns "live but UNSUPERVISED" on a state-write failure) is INVISIBLE to
+ * the tick, so its `.new-eager` was never consumed and the peer lay DOWN until an
+ * external stimulus (the owner's attach — which then also resumed the old context).
+ * This scan makes the mark a DURABLE contract independent of `.session`: every daemon
+ * tick, any `.new-eager` whose identity has NO live session AND NO `.session` (the
+ * standard path would have handled that) is relaunched fresh here. Guards: H4
+ * (launchd-managed → never touched), a LIVE session (self-fresh mark→kill window, or a
+ * concurrent wake that already brought it up — the mark stays; the standard path or the
+ * next tick consumes it), and the wake.lock inside wakeOrSpawn serializes against any
+ * concurrent message-wake (which itself now consumes the mark via resolveWakeMode 1.5).
+ */
+export async function processOrphanEagerMarks(
+  cfg: LifecycleConfig,
+  deps: WakeDeps & { wakeFn?: (args: WakeArgs, deps: WakeDeps) => Promise<WakeResult> } = {},
+): Promise<WakeResult[]> {
+  const env = deps.env ?? process.env
+  const wake = deps.wakeFn ?? wakeOrSpawn
+  let entries: string[] = []
+  try {
+    entries = readdirSync(cfg.stateDir).filter(f => f.endsWith('.new-eager'))
+  } catch {
+    return [] // no state dir → no marks
+  }
+  const results: WakeResult[] = []
+  for (const f of entries) {
+    const identity = f.slice(0, -'.new-eager'.length)
+    const addr = parseSessionName(identity)
+    if (!addr) continue
+    if (isLaunchdManaged(addr.personality, env)) continue // H4 — the daemon never touches launchd-owned peers
+    if (existsSync(sessionStatePath(cfg, identity))) continue // standard eager path owns this death
+    const sock = buildSocketPath(addr.runtime, addr.personality, cfg.sockDir)
+    if (sessionAlive(sock, identity, env)) continue // mark→kill window or already re-launched — leave the mark
+    appendLifecycleEvent(
+      cfg.eventLogDir,
+      { ev: 'supervise', identity, action: 'eager-orphan-fresh', reason: 'orphaned .new-eager (no .session, session dead)', outcome: 'eager-fresh' },
+      { env },
+    )
+    clearNewEager(cfg, identity) // consume — the relaunch below is fresh by construction
+    try {
+      results.push(await wake({ personality: addr.personality, runtime: addr.runtime, task: '', resume: false }, { cfg, env }))
+    } catch (e) {
+      results.push({ status: 'FAILED', woke: false, reason: e instanceof Error ? e.message : String(e) })
+    }
+  }
+  return results
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // wake_policy:"ephemeral" M3 — the serial-queue DRAIN. Deliveries to an ephemeral
 // target are always ENQUEUED (transport's injected ephemeral seam → queue.ts);

package/src/supervisor/daemon.ts

@@ -450,17 +450,37 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   // and a busy child's tick cadence has quiet gaps — the stability loop returns in such a gap
   // BEFORE the redraw arrives (proven by the repro byte log: the \x1b[NA redraw came as frame #2,
   // after the snapshot), which re-creates the dup exactly.
-  const awaitSeqBump = async (timeoutMs: number): Promise<void> => {
+  const awaitSeqBump = async (timeoutMs: number): Promise<boolean> => {
     const seq = writeSeq
     const deadline = Date.now() + timeoutMs
     while (writeSeq === seq && Date.now() < deadline) await Bun.sleep(15)
+    return writeSeq !== seq // true = the child actually emitted its SIGWINCH redraw (vs a silent child)
   }
   const firstAttach = async (s: { write(b: Buffer): number }, c: number, r: number): Promise<void> => {
     await awaitModelParsedStable()
+    // ORPHAN-SCROLLBACK on a shrinking attach (Артур welcome-attach corruption, 04.07 — live repro):
+    // the model is hosted at HOST 220x50; a real terminal attaches NARROWER (e.g. 120x30). applyGeometry
+    // REFLOWS the model (220→120): every wide line rewraps TALLER, and with fewer rows the TOP of the
+    // pre-resize viewport SPILLS into scrollback. The child's SIGWINCH redraw repaints only the VIEWPORT
+    // (a relative-cursor TUI can't reach scrollback), so the spilled rows linger as stale, reflow-wrapped
+    // orphans ABOVE the clean repaint — the "two frames overlaid + left-clipped" screenshot. This is a
+    // DIFFERENT artifact from the 0.4.59 viewport-dup (that stacked inside the viewport; this is scrollback).
+    const preBaseY = xterm.buffer.active.baseY // committed scrollback history depth BEFORE the resize
     if (c !== cols || r !== rows) {
       applyGeometry(c, r) // model + child together — one honest SIGWINCH, BEFORE the snapshot
-      await awaitSeqBump(SIGWINCH_REDRAW_WAIT_MS) // the redraw wave ARRIVES (or the child has none)
+      const redrew = await awaitSeqBump(SIGWINCH_REDRAW_WAIT_MS) // the redraw wave ARRIVES (or the child has none)
       await awaitModelParsedStable() // …then drain it to stability (bounded, В25 cap)
+      // Erase the orphan scrollback ONLY when it is PROVABLY 100% orphan: preBaseY===0 means there was NO
+      // committed history — the ENTIRE pre-resize screen was the child's dynamic tree, which the redraw has
+      // now fully repainted into the viewport, so every post-resize scrollback row is a redundant spilled
+      // copy. Erase it server-side (ESC[3J on the MODEL → serialize then carries only the clean viewport;
+      // no clear reaches the client's native scrollback). GUARDED on an actual redraw (a silent child keeps
+      // its only copy) and on new scrollback existing. preBaseY>0 (real scroll-up history) is left intact:
+      // the history/dynamic-tree seam lives inside the child's renderer and can't be derived here, so we
+      // never risk dropping real history — that narrower case is a separate follow-up.
+      if (redrew && preBaseY === 0 && xterm.buffer.active.baseY > 0) {
+        await new Promise<void>(res => xterm.write('\x1b[3J', () => res())) // eraseScrollback + parse barrier
+      }
     }
     sendSnapshot(s) // serialize the post-redraw model → send → lift gate (synchronous, no interleave)
   }