@agfpd/iapeer 0.4.56 → 0.4.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.56",
+  "version": "0.4.57",
   "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/supervisor/boot.ts

@@ -54,3 +54,39 @@ export function nextNagAction(adapter: NagPredicate, viewport: string, enc: KeyE
   if (keys && keys.length) return { kind: 'dismiss', keys, bytes: keysToBytes(keys, enc) }
   return { kind: 'none' }
 }
+
+// ── В60 — stuck-gate for the nag-watcher (timing signal, closer to the root than text) ────────────
+// A REAL blocked modal freezes the pty: claude stops writing entirely (the dialog is static and the
+// session cannot proceed). A LIVE peer that merely RENDERS the modal text — reviewing this code,
+// quoting a bug report, editing the adapter (the В40 live incident class) — keeps WRITING (streamed
+// output, spinner frames). So "the pane has written NOTHING for a while" discriminates a genuinely
+// stuck modal from a working peer displaying the same glyphs, where any text/position match
+// structurally cannot. The gate composes WITH the В40 position match (both must pass); the watcher
+// stays load-bearing (В59 suppression-at-source is expected but unproven) — this gate just limits its
+// fire to a genuinely wedged session.
+
+/** Mutable gate state the caller owns (one per watched session). */
+export interface StuckGate {
+  /** The last write-sequence observed (any pty output bumps it). -1 = not yet baselined. */
+  lastSeq: number
+  /** Wall-clock ms when the sequence last CHANGED (progress observed). */
+  stableSinceMs: number
+}
+
+export function newStuckGate(nowMs: number): StuckGate {
+  return { lastSeq: -1, stableSinceMs: nowMs }
+}
+
+/**
+ * One gate step: feed the current write-sequence + clock; returns true iff the pane has been
+ * COMPLETELY static (no pty writes) for at least `thresholdMs`. Any progress re-arms the gate.
+ * Pure w.r.t. time (clock injected) — unit-testable.
+ */
+export function paneIsStuck(gate: StuckGate, seq: number, nowMs: number, thresholdMs: number): boolean {
+  if (seq !== gate.lastSeq) {
+    gate.lastSeq = seq
+    gate.stableSinceMs = nowMs
+    return false
+  }
+  return nowMs - gate.stableSinceMs >= thresholdMs
+}

package/src/supervisor/daemon.ts

@@ -26,7 +26,7 @@ import {
   stripQueries,
 } from './protocol.ts'
 import { attachedPath, geometryPath, pidPath, servePath, sockPath, writeGeometry, writePidFile } from './paths.ts'
-import { nextBootAction, nextNagAction, type BootPredicates, type NagPredicate } from './boot.ts'
+import { newStuckGate, nextBootAction, nextNagAction, paneIsStuck, type BootPredicates, type NagPredicate } from './boot.ts'
 import { modelToPlainText } from './render.ts'
 import { codexAdapter } from '../launch/adapters/codex.ts'
 import { claudeAdapter } from '../launch/adapters/claude.ts'
@@ -87,6 +87,10 @@ const BOOT_DRIVE_MS = 120_000
 // survives the hold (our key did not take), the next tick re-fires, so retries stay bounded, not lost.
 const NAG_POLL_MS = 2000
 const NAG_COOLDOWN_MS = 4000
+/** В60 — how long the pane must be COMPLETELY static (no pty writes) before the nag-watcher may
+ *  fire. A genuinely blocked modal freezes the session forever, so a ~10 s delay costs nothing;
+ *  a live peer rendering the modal text keeps writing (stream/spinner) and never crosses this. */
+const NAG_STUCK_MS = 10_000
 // В25 — cap the attach-snapshot stabilization wait: under saturating output the model never goes quiet,
 // so without a budget firstAttach would never complete (frozen attach). On timeout we snapshot the
 // current model; live-forward delivers the rest once the gate lifts.
@@ -610,11 +614,17 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   const nagAdapter = BOOT_ADAPTERS[runtime] as NagPredicate | undefined
   if (nagAdapter?.nagDismissKeys) {
     let nagFiredMs = 0
+    // В60 — stuck-gate: a REAL blocked modal freezes the pty entirely, while a live peer merely
+    // RENDERING the modal text (code review / quoted report — the В40 false-fire class) keeps
+    // writing. Fire the dismiss ONLY when the pane has been completely static (writeSeq unchanged)
+    // for NAG_STUCK_MS — the timing signal composes with the adapter's position match.
+    const stuckGate = newStuckGate(Date.now())
     const nagWatch = setInterval(() => {
       if (down) {
         clearInterval(nagWatch)
         return
       }
+      if (!paneIsStuck(stuckGate, writeSeq, Date.now(), NAG_STUCK_MS)) return // progressing → not a wedged modal
       if (Date.now() - nagFiredMs < NAG_COOLDOWN_MS) return // let a just-answered modal repaint away first
       let action
       try {