@agfpd/iapeer 0.2.45 → 0.2.47

package/package.json

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

package/src/cli/cli.test.ts

@@ -476,10 +476,27 @@ describe('add-runtime / default-runtime (fleet-switch levers)', () => {
     expect(prof.runtime).toBe('claude') // default_runtime NOT flipped
     const rec = findPeer(readPeersIndex({ env: e }), 'aud1')!
     expect(rec.runtimes).toContain('codex')
+    expect(rec.runtime).toBe('claude') // registry default NOT flipped (capability ≠ routing; live-caught: upsert's «args.runtime wins» needed the reindex heal)
     // idempotent
     expect((await addRuntime('codex', { peer: 'aud1', env: e }))[0].action).toBe('already')
   })
 
+  test('add-runtime works from INSIDE another peer session (poisoned PEER_* env) — live-caught 12.06', async () => {
+    const e = env()
+    e.PEER_PERSONALITY = 'iapeer' // the caller's own identity must not poison the target's init
+    e.PEER_RUNTIME = 'claude'
+    e.PEER_IDENTITY = 'claude-iapeer'
+    const cwd = join(root, 'peers', 'aud3')
+    mkdirSync(cwd, { recursive: true })
+    await upsertPeer({ personality: 'aud3', runtime: 'claude', cwd, intelligence: 'artificial' }, { rootDir: root })
+    const { initPeer } = await import('../init/index.ts')
+    const cleanE = { ...e }
+    delete cleanE.PEER_PERSONALITY; delete cleanE.PEER_RUNTIME; delete cleanE.PEER_IDENTITY
+    await initPeer({ cwd, runtime: 'claude', env: cleanE })
+    const outcomes = await addRuntime('codex', { peer: 'aud3', env: e })
+    expect(outcomes[0].action).toBe('added')
+  })
+
   test('add-runtime refuses an infra runtime as the argument', async () => {
     await register('x1')
     await expect(addRuntime('telegram', { peer: 'x1', env: env() })).rejects.toThrow('infra runtime')

package/src/cli/index.ts

@@ -303,6 +303,14 @@ export async function addRuntime(
   const index = readPeersIndex({ env })
   const targets = opts.all === true ? index.peers : index.peers.filter(p => p.personality === opts.peer)
   if (targets.length === 0) throw new Error(opts.peer ? `peer "${opts.peer}" is not registered` : 'no targets — pass --peer <p> or --all')
+  // CROSS-PEER operation: strip the CALLER's identity env (PEER_*) — an operator
+  // (or an agent peer) running this from inside their own session would otherwise
+  // poison the TARGET's ensurePeerProfile identity check (live-caught on the very
+  // first 0.2.45 probe: PEER_PERSONALITY="iapeer" vs target "twpar" → failed).
+  const cleanEnv: NodeJS.ProcessEnv = { ...env }
+  delete cleanEnv.PEER_PERSONALITY
+  delete cleanEnv.PEER_RUNTIME
+  delete cleanEnv.PEER_IDENTITY
   const { initPeer } = await import('../init/index.ts')
   const out: AddRuntimeOutcome[] = []
   for (const p of targets) {
@@ -316,12 +324,18 @@ export async function addRuntime(
     }
     try {
       const warns: string[] = []
-      await initPeer({ cwd: p.cwd, runtime: runtime as Runtime, env, warn: m => warns.push(m) })
+      await initPeer({ cwd: p.cwd, runtime: runtime as Runtime, env: cleanEnv, warn: m => warns.push(m) })
       out.push({ personality: p.personality, action: 'added', detail: warns.length ? warns.join(' | ') : undefined })
     } catch (e) {
       out.push({ personality: p.personality, action: 'failed', detail: e instanceof Error ? e.message : String(e) })
     }
   }
+  // Self-heal the registry from the locals: provisionPeer's upsert sets the record's
+  // default to the PROVISIONED runtime («args.runtime wins» — right for births, wrong
+  // here: add-runtime is capability-only and must NOT flip routing). The reindex
+  // REPLACE projection restores the local profile's untouched default (live-caught
+  // on the 0.2.45 probe: registry default flipped to codex while the local kept claude).
+  if (out.some(o => o.action === 'added')) await reindexFromLocals({ env })
   return out
 }
 

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()