@agfpd/iapeer 0.2.46 → 0.2.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.46",
+  "version": "0.2.48",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "type": "module",
   "bin": {

package/src/launch/adapters/codex.ts

@@ -223,17 +223,28 @@ export const codexAdapter: RuntimeAdapter = {
   },
 
   /**
-   * Ready for the first message iff the codex TUI input surface is rendered and
-   * no startup screen is still up (watcher.codexInputReady, 263-269):
-   *   - pane includes 'OpenAI Codex' — the TUI splash/header is present.
+   * Ready for the first message iff the codex TUI composer is rendered and no
+   * startup screen is still up:
    *   - pane does NOT include 'Press enter to continue' — the update screen (and
-   *     other "press enter" startup prompts) is gone.
+   *     other "press enter" startup prompts) is gone (belt-and-suspenders: the
+   *     boot loop answers known dialogs via bootDialogKeys BEFORE asking this).
    *   - some line, trimStart, startsWith '› ' — the rendered input arrow at the
-   *     start of the input row. (Codex rotates its top-of-pane tip line, so the
-   *     input arrow is the stable ready invariant — not any single tip.)
+   *     start of the composer row. (Codex rotates its top-of-pane tip line, so
+   *     the input arrow is the stable ready invariant — not any single tip.)
+   *
+   * DELIBERATELY no 'OpenAI Codex' splash check (the watcher.codexInputReady
+   * heritage requirement, removed 12.06): `resume --last` replays the prior
+   * transcript ABOVE the composer, and a history taller than the pane scrolls
+   * the splash box off the top of capture-pane — the predicate then stays false
+   * for the entire boot deadline while the composer sits ready, failing the wake
+   * `never-became-ready` and LOSING the triggering message (live incidents
+   * 11.06 19:21Z + 12.06 12:07Z, codex-linus). A replayed history message also
+   * renders with a leading '› ', so this can fire a frame before the composer
+   * activates — benign: the paste/Enter queue in the pty and land in the
+   * composer, and the ready-gate still verifies a real model turn (activity
+   * mtime advance) before declaring READY.
    */
   isInputReady(pane: string): boolean {
-    if (!pane.includes('OpenAI Codex')) return false
     if (pane.includes('Press enter to continue')) return false
     return pane.split(/\r?\n/).some(line => line.trimStart().startsWith('› '))
   },

package/src/launch/index.ts

@@ -114,6 +114,22 @@ function sleep(ms: number): Promise<void> {
 function fail(identity: string, reason: string): LaunchResult {
   return { status: 'FAILED', identity, process_address: identity, reason }
 }
+
+/**
+ * The last two non-empty lines of a pane capture, flattened for embedding in a
+ * fail reason: quotes → ', whitespace runs collapsed, joined with ' ⏎ ', clipped
+ * to 160 chars. '' for an empty/blank capture (caller omits the clause). Exported
+ * for unit tests — the boot loop embeds this in `never-became-ready` so the
+ * delivery.log err field shows what the TUI was actually displaying.
+ */
+export function paneTail(pane: string): string {
+  const lines = pane
+    .split(/\r?\n/)
+    .map(l => l.replace(/\s+/g, ' ').trim())
+    .filter(Boolean)
+  if (lines.length === 0) return ''
+  return lines.slice(-2).join(' ⏎ ').replace(/"/g, "'").slice(0, 160)
+}
 function ready(identity: string): LaunchResult {
   return { status: 'READY', identity, process_address: identity }
 }
@@ -347,6 +363,7 @@ export const launch: LaunchFn = async (
   const baselineMtime = adapter.newestActivityMtime(cwd) ?? 0
   const bootIters = Math.max(1, Math.ceil(cfg.bootDeadlineSecs / 2))
   let delivered = false
+  let lastPane = '' // the final capture — surfaced in the never-became-ready reason
   for (let i = 0; i < bootIters && !delivered; i++) {
     await sleep(2000)
     if (!sessionAlive(sock, identity)) {
@@ -354,6 +371,7 @@ export const launch: LaunchFn = async (
     }
     const pane = capturePane(sock, identity)
     if (!pane) continue
+    lastPane = pane
     const dialogKeys = adapter.bootDialogKeys(pane)
     if (dialogKeys) {
       tmux(sock, 'send-keys', '-t', identity, ...dialogKeys)
@@ -390,7 +408,15 @@ export const launch: LaunchFn = async (
     }
   }
   if (!delivered) {
-    return fail(identity, 'never-became-ready (stuck at a startup prompt or boot hang)')
+    // Surface WHAT the pane showed when the gate gave up — the 12.06 codex-resume
+    // incident (splash scrolled off, composer ready, predicate false for 240 s) was
+    // undiagnosable from the bare reason alone. Last two non-empty lines, quotes
+    // flattened (the reason lands inside a logfmt-quoted err field), clipped.
+    const tail = paneTail(lastPane)
+    return fail(
+      identity,
+      `never-became-ready (stuck at a startup prompt or boot hang)${tail ? `; pane tail: ${tail}` : ''}`,
+    )
   }
 
   // (7) READY-GATE — the activity proxy must strictly advance past baseline

package/src/launch/launch.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { exitCauseHook, exitLogPath, getAdapter, launch } from './index.ts'
+import { exitCauseHook, exitLogPath, getAdapter, launch, paneTail } from './index.ts'
 import { claudeAdapter } from './adapters/claude.ts'
 import { codexAdapter } from './adapters/codex.ts'
 import { telegramAdapter } from './adapters/telegram.ts'
@@ -74,6 +74,64 @@ describe('codexAdapter.buildArgv', () => {
   })
 })
 
+describe('codexAdapter.isInputReady', () => {
+  test('fresh boot: splash + composer → true', () => {
+    const pane = [
+      '╭───────────────────────────────╮',
+      '│ >_ OpenAI Codex (v0.138.0)    │',
+      '╰───────────────────────────────╯',
+      '› Explain this codebase',
+      'gpt-5.5 xhigh · ~/Peers/p',
+    ].join('\n')
+    expect(codexAdapter.isInputReady(pane)).toBe(true)
+  })
+
+  test('resume replay scrolled the splash off — composer alone is READY (12.06 incident)', () => {
+    // The live zombie pane shape: history tail + MCP noise + composer, NO
+    // 'OpenAI Codex' anywhere in the visible capture. The old predicate required
+    // the splash and spun false for the whole 240 s boot deadline.
+    const pane = [
+      '  <message><![CDATA[Компакт прошел?]]></message>',
+      '  </iap>',
+      '• Принял. Ответ пиру не слал: он явно написал, что больше ничего не нужно.',
+      '⚠ MCP startup incomplete (failed: iap)',
+      '› Explain this codebase',
+      'gpt-5.5 xhigh · ~/Peers/p',
+    ].join('\n')
+    expect(pane.includes('OpenAI Codex')).toBe(false) // fixture honesty
+    expect(codexAdapter.isInputReady(pane)).toBe(true)
+  })
+
+  test('update screen up → false even with a composer-looking line', () => {
+    const pane = ['Update available!', 'Press enter to continue', '› something'].join('\n')
+    expect(codexAdapter.isInputReady(pane)).toBe(false)
+  })
+
+  test('no composer row yet (box only, model loading) → false', () => {
+    const pane = ['│ >_ OpenAI Codex (v0.138.0) │', '│ model: loading │'].join('\n')
+    expect(codexAdapter.isInputReady(pane)).toBe(false)
+  })
+
+  test('bare › without trailing space (a stray glyph) → false', () => {
+    expect(codexAdapter.isInputReady('›\nnothing else')).toBe(false)
+  })
+})
+
+describe('paneTail (never-became-ready observability)', () => {
+  test('last two non-empty lines, joined, quotes flattened', () => {
+    const pane = 'first\n\n  middle  line \n⚠ MCP "failed"\n› composer\n\n'
+    expect(paneTail(pane)).toBe("⚠ MCP 'failed' ⏎ › composer")
+  })
+  test('single line and empty captures', () => {
+    expect(paneTail('only')).toBe('only')
+    expect(paneTail('')).toBe('')
+    expect(paneTail('\n  \n')).toBe('')
+  })
+  test('clips to 160 chars', () => {
+    expect(paneTail('x'.repeat(300)).length).toBe(160)
+  })
+})
+
 describe('telegramAdapter (router — no TUI surface)', () => {
   test('router predicates are trivial', () => {
     expect(telegramAdapter.bootDialogKeys('anything')).toBeNull()

package/src/lifecycle/index.ts

@@ -1251,20 +1251,29 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
  * consumed BEFORE the relaunch so a relaunch failure does not loop on the same eager mark
  * (it then fresh-wakes lazily on its next message — branch 3a — never lost). NB: a /new'd
  * peer is expected to carry an initial_prompt; without one the first turn delivers nothing.
+ *
+ * Runtime is DELIBERATELY NOT pinned to the dead session's runtime: the relaunch passes
+ * no runtime so resolveWakeRuntime falls through to the registry default (H5 — registry
+ * is the only source of wake-runtime truth). Pinning broke the fleet-switch procedure
+ * (`default-runtime <rt>` + `self-fresh`): the peer silently resurrected on the OLD
+ * runtime, ignoring the just-flipped default (live incident 12.06, claude-iapeer). A
+ * session deliberately living on a non-default runtime has explicit paths back (wake
+ * with an explicit runtime); an owner /new returns the peer to its declared default.
  */
 export async function processEagerRelaunches(
   cfg: LifecycleConfig,
   outcomes: SuperviseOutcome[],
-  deps: WakeDeps = {},
+  deps: WakeDeps & { wakeFn?: (args: WakeArgs, deps: WakeDeps) => Promise<WakeResult> } = {},
 ): Promise<WakeResult[]> {
+  const wake = deps.wakeFn ?? wakeOrSpawn
   const results: WakeResult[] = []
   for (const o of outcomes) {
-    if (o.action !== 'needs-eager-fresh' || !o.personality || !o.runtime) continue
+    if (o.action !== 'needs-eager-fresh' || !o.personality) continue
     clearNewEager(cfg, o.identity) // consume the eager mark — the relaunch is fresh by construction
     try {
       results.push(
-        await wakeOrSpawn(
-          { personality: o.personality, runtime: o.runtime, task: '', resume: false },
+        await wake(
+          { personality: o.personality, task: '', resume: false },
           { cfg, env: deps.env },
         ),
       )

package/src/lifecycle/lifecycle.test.ts

@@ -621,6 +621,38 @@ describe('superviseTick death-cause accounting (TARGET)', () => {
     }
   })
 
+  test('eager relaunch does NOT pin the dead session runtime — re-resolves from the registry (H5 fleet-switch)', async () => {
+    // Live incident 12.06: `default-runtime codex` + `self-fresh` resurrected the peer
+    // on the OLD runtime — the relaunch passed the dead session's runtime EXPLICITLY,
+    // so resolveWakeRuntime never consulted the just-flipped registry default.
+    const { env, cfg, root, laDir } = deadSessionEnv('rt')
+    try {
+      setNewEager(cfg, 'claude-rt')
+      const outcomes = superviseTick(cfg, { env })
+      const o = outcomes.find(x => x.identity === 'claude-rt')
+      expect(o?.action).toBe('needs-eager-fresh')
+      const seen: Array<{ personality: string; runtime?: string; resume?: boolean; task: string }> = []
+      const { processEagerRelaunches } = await import('./index.ts')
+      await processEagerRelaunches(cfg, outcomes, {
+        env,
+        wakeFn: async args => {
+          seen.push({ personality: args.personality, runtime: args.runtime, resume: args.resume, task: args.task })
+          return { status: 'READY', woke: true }
+        },
+      })
+      expect(seen.length).toBe(1)
+      expect(seen[0].personality).toBe('rt')
+      expect(seen[0].runtime).toBeUndefined() // ← the fix: wakeOrSpawn re-resolves from the registry
+      expect(seen[0].resume).toBe(false)
+      expect(seen[0].task).toBe('')
+      // the mark was consumed by the relaunch
+      expect(hasNewEager(cfg, 'claude-rt')).toBe(false)
+    } finally {
+      rmSync(root, { recursive: true, force: true })
+      rmSync(laDir, { recursive: true, force: true })
+    }
+  })
+
   test('a DEAD session with NO .new-eager → reaped-gone, NO .idle-reaped written (crash leaves no marker)', () => {
     const { env, cfg, root, laDir } = deadSessionEnv('w')
     try {