@agfpd/iapeer 0.4.79 → 0.4.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.79",
+  "version": "0.4.81",
   "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

@@ -121,36 +121,54 @@ export function nextNagAction(adapter: NagPredicate, viewport: string, enc: KeyE
   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.
+/**
+ * Content signature of a NagAction for the stability gate (below) — identifies "the SAME wedged prompt"
+ * across ticks so a repainting modal is recognized as one persistent prompt, not fresh each frame.
+ *   - 'approve' → taxonomy + the verbatim `detail` (the modal block for unknown-modal, the command/target
+ *     trace for a known breaker) — stable and unique per prompt.
+ *   - 'dismiss' → the dismiss keys (constant while a given nag is up).
+ *   - 'none'    → null (nothing actionable → the gate re-arms).
+ */
+export function nagSignature(action: NagAction): string | null {
+  if (action.kind === 'approve') return `approve:${action.taxonomy}:${action.detail}`
+  if (action.kind === 'dismiss') return `dismiss:${action.keys.join(',')}`
+  return null
+}
+
+// ── В60/В61 — stability gate for the nag-watcher (content signature, NOT raw pty writes) ────────────
+// The watcher must fire ONLY on a genuinely WEDGED prompt, never on a live peer merely RENDERING modal-
+// like text (reviewing this code, quoting a bug report — the В40 incident class). The ORIGINAL В60 signal
+// was "the pty wrote NOTHING for a while" (writeSeq frozen): a claude modal freezes the pty, a working
+// peer keeps streaming. But codex DEFEATS that — it REPAINTS its native approval modal continuously (live
+// repro eph-cdxdet 08.07: pane-log grew ~788 B every 2 s while the RENDERED modal was byte-identical), so
+// writeSeq never froze and the watcher NEVER fired (0 events, peer hung on the modal). The correct signal
+// is one level up: the DETECTED action's CONTENT is stable. A wedged modal holds the SAME signature across
+// ticks even while its bytes churn; a working/streaming peer changes it (or shows no actionable modal) and
+// re-arms. This composes WITH the adapter's structural match (detectNumberedModal's composer-replaced guard
+// already rejects a quoted modal) — the gate just requires that match to PERSIST, so a transient render
+// never fires. Covers BOTH runtimes: claude's static modal and codex's repainting one stabilize identically.
 
 /** 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). */
+export interface StabilityGate {
+  /** The last content signature observed (nagSignature). null = not yet baselined / nothing actionable. */
+  lastSig: string | null
+  /** Wall-clock ms when the signature last CHANGED. */
   stableSinceMs: number
 }
 
-export function newStuckGate(nowMs: number): StuckGate {
-  return { lastSeq: -1, stableSinceMs: nowMs }
+export function newStabilityGate(nowMs: number): StabilityGate {
+  return { lastSig: null, 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.
+ * One gate step: feed the current content signature + clock; returns true iff the SAME NON-NULL signature
+ * has persisted for at least `thresholdMs`. A null signature (nothing actionable) or a CHANGED signature
+ * re-arms the gate (returns false) and records the new stableSince. Pure w.r.t. time (clock injected) —
+ * unit-testable, and INDEPENDENT of raw pty write cadence (a repainting-but-content-stable modal fires).
  */
-export function paneIsStuck(gate: StuckGate, seq: number, nowMs: number, thresholdMs: number): boolean {
-  if (seq !== gate.lastSeq) {
-    gate.lastSeq = seq
+export function signatureStable(gate: StabilityGate, sig: string | null, nowMs: number, thresholdMs: number): boolean {
+  if (sig === null || sig !== gate.lastSig) {
+    gate.lastSig = sig
     gate.stableSinceMs = nowMs
     return false
   }

package/src/supervisor/daemon.ts

@@ -27,7 +27,7 @@ import {
 } from './protocol.ts'
 import { formatEventLine } from '../storage/rotatelog.ts'
 import { attachedPath, geometryPath, pidPath, servePath, sockPath, writeGeometry, writePidFile } from './paths.ts'
-import { newStuckGate, nextBootAction, nextNagAction, paneIsStuck, type BootPredicates, type NagPredicate } from './boot.ts'
+import { newStabilityGate, nagSignature, nextBootAction, nextNagAction, signatureStable, 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'
@@ -725,25 +725,18 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
     // (writeSeq advance) so a later, DIFFERENT modal is handled fresh.
     let unknownModalAttempts = 0
     let unknownModalParked = false
-    let lastNagSeq = -1
-    // В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())
+    let lastNagSig: string | null = null
+    // В60/В61 — fire ONLY on a genuinely WEDGED prompt, gated on the detected modal/nag's CONTENT
+    // STABILITY, not raw pty writes: codex REPAINTS its native approval modal every ~2 s, so a writeSeq
+    // stuck-gate never froze and the watcher never fired (live repro eph-cdxdet 08.07: 0 events, peer hung).
+    // The SAME signature persisting for NAG_STUCK_MS is the "wedged" signal; a working/streaming peer changes
+    // it (or shows no modal) and re-arms. Composes with the adapter's structural match. See signatureStable.
+    const stabilityGate = newStabilityGate(Date.now())
     const nagWatch = setInterval(() => {
       if (down) {
         clearInterval(nagWatch)
         return
       }
-      // Pane made PROGRESS since last tick → the modal (if any) cleared / the peer moved on: reset the
-      // unknown-modal re-enqueue counters so a subsequent, different modal starts a fresh budget.
-      if (writeSeq !== lastNagSeq) {
-        lastNagSeq = writeSeq
-        unknownModalAttempts = 0
-        unknownModalParked = false
-      }
-      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 {
@@ -752,6 +745,16 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
       } catch {
         return // transient model read — retry next tick
       }
+      // Debounce on the detected action's CONTENT signature (not writeSeq — codex repaints its modal, so
+      // writeSeq churns while the modal is stable). A NEW/absent signature (a different modal, or the modal
+      // cleared) resets the unknown-modal re-enqueue budget so a later modal starts a fresh budget.
+      const sig = nagSignature(action)
+      if (sig !== lastNagSig) {
+        lastNagSig = sig
+        unknownModalAttempts = 0
+        unknownModalParked = false
+      }
+      if (!signatureStable(stabilityGate, sig, Date.now(), NAG_STUCK_MS)) return // not stable long enough → not wedged
       if (action.kind === 'dismiss') {
         child.terminal.write(action.bytes)
         nagFiredMs = Date.now()

package/src/transport/index.ts

@@ -307,7 +307,7 @@ async function deliverViaHost(
   // a short grace covers it. The receiver's own assistant/tool turn never reproduces the
   // `<iap from-personality=…>` wrapper, so it cannot forge a confirm. No such record within the grace →
   // false-FAIL (the sender retries) — NOT a false-OK (silent loss the contract forbids).
-  const confirm = seam.confirmLanded ?? ((payload: string) => transcriptCarriesEnvelope(baseline, payload))
+  const confirm = seam.confirmLanded ?? ((payload: string) => transcriptCarriesEnvelope(baseline, payload, { env }))
   const sleep = seam.sleep ?? ((ms: number) => new Promise<void>(r => setTimeout(r, ms)))
   const graceMs = confirmGraceMs()
   const graceDeadline = monotonicMs() + graceMs
@@ -579,20 +579,37 @@ function jsonStringValuesContain(value: unknown, needle: string): boolean {
  * the full envelope is UNFORGEABLE by a concurrent turn — no false-OK. Because only bytes PAST the
  * baseline offset are read, a pre-existing copy of an identical earlier message cannot pass either.
  *
- * Iterates the baseline file LIST verbatim — it does NOT re-scan the runtime's session dir each poll
- * (unlike the minutes-long compact-done gate). A delivery's confirm window is seconds, so a brand-new
- * session file appearing mid-delivery (a resume mid-flight) is negligible, and missing it fails in the
- * SAFE direction (false-FAIL → the sender retries, never a silent loss). For codex this also avoids a
- * full recursive `~/.codex/sessions` re-scan on every ~100ms poll (the active session file is already
- * in the baseline), keeping the hot delivery path cheap.
+ * Scans each baseline file from its captured offset AND any session file that APPEARS AFTER the baseline
+ * from offset 0 — the post-baseline pickup is load-bearing. A FRESH session (self-fresh/eager-fresh)
+ * writes its NEW jsonl LAZILY on the first delivered turn, so the confirming record for the FIRST delivery
+ * into that session lands in a file the baseline never captured (the fresh jsonl is born ~a beat AFTER the
+ * pre-deliver baseline snapshot). Iterating baseline-only made EVERY such first-delivery a false-FAIL: the
+ * dead OLD session file gets scanned, the live NEW one is ignored, and the confirm reported "not delivered"
+ * for a message the session had actually accepted + processed (verified live 2026-07-10: telegram-arthur →
+ * mrmechanic ok=false, yet the envelope stood in the fresh jsonl at +0.3s, within the grace). A
+ * post-baseline file is BRAND-NEW for this cwd, so reading it from 0 cannot match a pre-existing copy
+ * (nothing pre-existed), and the full `<iap from-personality=…>` envelope is unforgeable by the receiver's
+ * own assistant/tool turn — the SAME false-OK safety `compactTranscriptHasDone` already relies on. In
+ * production this loop runs ONLY for claude (codex confirms by the socket-ack BEFORE reaching here), so the
+ * per-poll re-list is a single cheap readdirSync of one project dir — never a recursive `~/.codex/sessions`
+ * walk. `env` scopes the re-list under a test HOME (default process.env).
  */
-export function transcriptCarriesEnvelope(baseline: CompactDoneBaseline, envelope: string): boolean {
+export function transcriptCarriesEnvelope(
+  baseline: CompactDoneBaseline,
+  envelope: string,
+  opts: { env?: NodeJS.ProcessEnv } = {},
+): boolean {
   const needle = envelope.replace(/\r/g, '')
   if (!needle) return false
-  for (const { path, size: offset } of baseline.files) {
-    // Read ONLY the tail past the baseline offset — a full readFileSync here re-read the ENTIRE
-    // transcript (hundreds of MB for a long-running peer) on every ~100ms confirm-poll, stalling the
-    // single-threaded router event loop for the whole fleet.
+  // Baseline files at their pre-deliver offset; a file NOT in the baseline (born after it) is read from 0.
+  const offsets = new Map(baseline.files.map(f => [f.path, f.size]))
+  for (const path of compactCandidateFiles(baseline.runtime, baseline.cwd, opts.env)) {
+    if (!offsets.has(path)) offsets.set(path, 0)
+  }
+  for (const [path, offset] of offsets) {
+    // Read ONLY the tail past the offset — a full readFileSync here re-read the ENTIRE transcript
+    // (hundreds of MB for a long-running peer) on every ~100ms confirm-poll, stalling the single-threaded
+    // router event loop for the whole fleet.
     const tail = readFileTailFrom(path, offset)
     if (!tail) continue
     for (const line of tail.split(/\r?\n/)) {