@agfpd/iapeer 0.4.27 → 0.4.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.4.27",
+  "version": "0.4.28",
   "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/launch/adapters/claude.ts

@@ -240,6 +240,38 @@ export const claudeAdapter: RuntimeAdapter = {
     return null
   },
 
+  /**
+   * MID-SESSION nag/upsell auto-dismiss (livability — distinct from bootDialogKeys,
+   * which the supervisor drives only until ready). claude pops a ONE-TIME interactive
+   * upsell modal AFTER the session is live that BLOCKS a headless peer (no human to
+   * answer):
+   *
+   *     Try the new fullscreen renderer?
+   *     · Flicker-free output …
+   *     ❯ 1. Yes, try it
+   *       2. Not now
+   *     Enter to confirm · Esc to cancel
+   *
+   * The default cursor sits on "1. Yes, try it", so a BARE Enter would ENABLE the
+   * fullscreen renderer — which switches claude to the alt-screen TUI and changes the
+   * surface the pane-log model + composer-occupancy + ready-gate all read off. We must
+   * DECLINE: type the literal '2' then Enter ('2','Enter' → "2\r"; '2' is not a named/
+   * cursor key, so it is emitted verbatim without a `-l` literal switch — and `-l`
+   * would wrongly make the following 'Enter' literal too). VERIFIED-SAFE on the live
+   * fleet: '2'+Enter cleared the modal on boris and doc and returned them to the
+   * composer; an arrow-step+Enter MIS-FIRED into "tui":"fullscreen" on scriber, and Esc/
+   * 'n' are unverified — so this is the ONLY accepted sequence. Match the FULL signature
+   * (title AND the "2. Not now" decline row) so a transcript merely DISCUSSING the
+   * fullscreen renderer can never trigger a stray keystroke. Future one-time CC upsells
+   * of this class extend the match here (each with its own verified-safe decline key).
+   */
+  nagDismissKeys(pane: string): string[] | null {
+    if (pane.includes('Try the new fullscreen renderer?') && pane.includes('2. Not now')) {
+      return ['2', 'Enter']
+    }
+    return null
+  },
+
   /**
    * Ready for the first message iff the input surface is rendered AND no startup
    * dialog is still up (lifecycle.claudeInputReady, index.ts:272-279;

package/src/launch/types.ts

@@ -259,6 +259,20 @@ export interface RuntimeAdapter {
    */
   bootDialogKeys(pane: string): string[] | null
 
+  /**
+   * MID-SESSION nag/upsell auto-dismiss (livability). Distinct from bootDialogKeys:
+   * the boot-driver stops at ready, but claude/codex can pop a ONE-TIME interactive
+   * upsell modal AFTER the session is live (e.g. "Try the new fullscreen renderer?")
+   * that BLOCKS the pty waiting for a keypress no headless peer answers — it froze the
+   * live fleet until a human cleared it. A persistent supervisor watcher (daemon.ts)
+   * runs THIS off the authoritative model for the whole session and writes the keys.
+   * Return the send-keys args that dismiss with the VERIFIED-SAFE default (decline),
+   * else null. Match the FULL modal signature so ordinary content mentioning the
+   * feature can never trigger a stray keystroke into the composer. Optional — a runtime
+   * with no known mid-session nags (codex/router) omits it. tui only.
+   */
+  nagDismissKeys?(pane: string): string[] | null
+
   /** Is the input surface ready for the first message? (tui: ready marker present
    *  AND startup dialogs gone). Router runtimes return true (no input surface). */
   isInputReady(pane: string): boolean

package/src/supervisor/boot.ts

@@ -32,3 +32,25 @@ export function nextBootAction(adapter: BootPredicates, viewport: string, enc: K
   if (adapter.isInputReady(viewport)) return { kind: 'ready' }
   return { kind: 'wait' }
 }
+
+/** The slice of a RuntimeAdapter the MID-SESSION nag-watcher consumes — the optional
+ *  nagDismissKeys (claudeAdapter satisfies it; codex/router omit it → no nags). */
+export interface NagPredicate {
+  nagDismissKeys?(pane: string): string[] | null
+}
+
+export type NagAction = { kind: 'dismiss'; keys: string[]; bytes: Buffer } | { kind: 'none' }
+
+/**
+ * MID-SESSION nag/upsell step (livability) — the persistent sibling of nextBootAction. Unlike the
+ * boot-driver, which STOPS at ready, the daemon loops this for the WHOLE session: a one-time CC upsell
+ * modal (e.g. "Try the new fullscreen renderer?") can pop AFTER the session is live and BLOCK the pty on
+ * a keypress no headless peer answers. If the adapter recognizes the (FULL-signature) modal it returns
+ * the verified-safe DECLINE keys; the caller writes `action.bytes` to the pty (cooldown-guarded so a
+ * cleared modal is never double-answered). An adapter with no nagDismissKeys → always 'none'.
+ */
+export function nextNagAction(adapter: NagPredicate, viewport: string, enc: KeyEncoding = {}): NagAction {
+  const keys = adapter.nagDismissKeys?.(viewport)
+  if (keys && keys.length) return { kind: 'dismiss', keys, bytes: keysToBytes(keys, enc) }
+  return { kind: 'none' }
+}

package/src/supervisor/daemon.ts

@@ -25,7 +25,7 @@ import {
   stripQueries,
 } from './protocol.ts'
 import { attachedPath, geometryPath, pidPath, servePath, sockPath, writeGeometry } from './paths.ts'
-import { nextBootAction, type BootPredicates } from './boot.ts'
+import { nextBootAction, nextNagAction, 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'
@@ -80,6 +80,12 @@ const BOOT_POLL_MS = 2000
 // Stop driving after this long even if readiness is never observed (a hung/unknown startup); the
 // driver is best-effort and never blocks the conduit, which keeps serving regardless.
 const BOOT_DRIVE_MS = 120_000
+// MID-SESSION nag-watcher cadence: same 2 s model poll as the boot-driver. After answering a nag, hold
+// this long before the next check so a just-dismissed modal (claude repaints it away within a frame) is
+// never re-answered — a stray keystroke would land in the now-visible composer. If the modal genuinely
+// 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
 
 // Bun-native PTY (Bun ≥1.3.5) is not yet in @types/bun — type the slice we use.
 interface PtyChild {
@@ -541,4 +547,38 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
     }, BOOT_POLL_MS)
     ;(driver as { unref?: () => void }).unref?.()
   }
+
+  // ── mid-session nag-watcher (livability) ────────────────────────────────────────
+  // The boot-driver above STOPS at ready. But claude/codex can pop a ONE-TIME upsell modal
+  // MID-SESSION (e.g. "Try the new fullscreen renderer?", which appears on the return-to-prompt
+  // boundary after a tool result) that BLOCKS the pty on a keypress no headless peer answers — it
+  // froze live fleet peers (boris, doc) until a human cleared it by hand. A PERSISTENT watcher answers
+  // the curated, verified-safe DECLINE for that class off the SAME authoritative @xterm model, for the
+  // WHOLE session lifetime, exactly like the boot-driver answers startup dialogs — model-read
+  // (modelToPlainText) + raw pty-byte-write (keysToBytes). Cooldown-guarded: after firing, hold
+  // NAG_COOLDOWN_MS so a just-dismissed modal is never double-answered (a stray keystroke would land in
+  // the now-visible composer). Only runs for a runtime whose adapter declares nagDismissKeys.
+  const nagAdapter = BOOT_ADAPTERS[runtime] as NagPredicate | undefined
+  if (nagAdapter?.nagDismissKeys) {
+    let nagFiredMs = 0
+    const nagWatch = setInterval(() => {
+      if (down) {
+        clearInterval(nagWatch)
+        return
+      }
+      if (Date.now() - nagFiredMs < NAG_COOLDOWN_MS) return // let a just-answered modal repaint away first
+      let action
+      try {
+        const enc = { appCursorKeys: xterm.modes.applicationCursorKeysMode }
+        action = nextNagAction(nagAdapter, modelToPlainText(xterm, cols, rows), enc)
+      } catch {
+        return // transient model read — retry next tick
+      }
+      if (action.kind === 'dismiss') {
+        child.terminal.write(action.bytes)
+        nagFiredMs = Date.now()
+      }
+    }, NAG_POLL_MS)
+    ;(nagWatch as { unref?: () => void }).unref?.()
+  }
 }