@agfpd/iapeer 0.2.67 → 0.2.68

package/package.json

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

package/src/launch/ptyHost.ts

@@ -14,7 +14,9 @@ import { existsSync, readFileSync } from 'node:fs'
 import { deliverToHost, type DeliverResult } from '../supervisor/deliver.ts'
 import { attachedPath, defaultRunDir, pidPath } from '../supervisor/paths.ts'
 import { sessionAlive as hostDaemonAlive } from '../supervisor/client.ts'
-import { killSession as killSupervisorSession } from '../supervisor/index.ts'
+import { killSession as killSupervisorSession, listSessions as listSupervisorSessions } from '../supervisor/index.ts'
+import { parseSessionName } from '../core/socket.ts'
+import type { TmuxRuntime } from '../core/constants.ts'
 import { paneLogViewport } from './readyGateModel.ts'
 import type { LaunchInvocation } from './invocation.ts'
 import type { RuntimeAdapter } from './types.ts'
@@ -80,6 +82,22 @@ export function hostSessionToken(identity: string): string | null {
   }
 }
 
+/**
+ * Online supervisor-HOSTED peers (spawn-flip Ф0b-3): live sessions in the supervisor run-dir. A hosted
+ * peer has NO tmux socket, so the tmux-based listOnlinePeers scan can't see it — this lets the online
+ * scan (and the no-runtime delivery resolve) include hosted peers. Empty + cheap when flag-off (the
+ * run-dir is empty).
+ */
+export function listHostedPeers(): Array<{ runtime: TmuxRuntime; personality: string }> {
+  const out: Array<{ runtime: TmuxRuntime; personality: string }> = []
+  for (const s of listSupervisorSessions(hostRunDir())) {
+    if (!s.alive) continue
+    const p = parseSessionName(s.session)
+    if (p) out.push({ runtime: p.runtime, personality: p.personality })
+  }
+  return out
+}
+
 export interface HostStartResult {
   ok: boolean
   error?: string

package/src/lifecycle/index.ts

@@ -1255,9 +1255,16 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
       // alive server means the previous canary VANISHED mid-watch (the death-#4
       // blind spot was exactly this churn being invisible); 'failed' means the
       // server is currently UNWATCHED. At most one line per loss, not per tick.
-      const canaryState = ensureServerCanary({ identity: s.identity, sock, exitLogDir: cfg.eventLogDir, env })
-      if (canaryState !== 'already') {
-        trace({ identity: s.identity, action: 'canary', state: canaryState, origin: 'retrofit' })
+      // SPAWN-FLIP Ф0b-3: the tmux server-death canary is meaningless for a supervisor-HOSTED session
+      // (no tmux server — the retrofit arms a watcher that immediately fires a spurious
+      // `server-vanished`). A hosted death is recorded by the supervisor's exits.log (host=supervisor,
+      // resilience-b), so skip the canary retrofit for hosted peers (mirror of the observer .pty-host
+      // skip — tmux-assuming infra must not run against a hosted session).
+      if (!hostSessionAlive(s.identity)) {
+        const canaryState = ensureServerCanary({ identity: s.identity, sock, exitLogDir: cfg.eventLogDir, env })
+        if (canaryState !== 'already') {
+          trace({ identity: s.identity, action: 'canary', state: canaryState, origin: 'retrofit' })
+        }
       }
       out.push({ identity: s.identity, action: 'alive' })
       if (verbose) trace({ identity: s.identity, action: 'alive', age: `${ageSecs}s` })

package/src/transport/hostLive.test.ts

@@ -0,0 +1,50 @@
+// Spawn-flip Ф0b-3 — transport liveness/resolution is HOST-AWARE. The canary exposed it: a genuinely
+// supervisor-HOSTED peer (live supervisor .pid, NO tmux) was seen as OFFLINE by resolveDeliveryTarget/
+// isPeerLive (transport had its OWN tmux-only sessionAlive, separate from the Ф0b-1 lifecycle fix), so
+// routeSend mis-routed a warm hit to a wake and the post-wake verify-before-act false-failed. This
+// binds the fix: a live supervisor .pid → live, even with no tmux.
+import { afterEach, describe, expect, test } from 'bun:test'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { hostRunDir } from '../launch/ptyHost.ts'
+import { isPeerLive, listOnlinePeers } from './index.ts'
+
+describe('isPeerLive — host-aware (spawn-flip Ф0b-3)', () => {
+  const savedRoot = process.env.IAPEER_ROOT
+  let root: string | null = null
+  afterEach(() => {
+    if (savedRoot === undefined) delete process.env.IAPEER_ROOT
+    else process.env.IAPEER_ROOT = savedRoot
+    if (root) rmSync(root, { recursive: true, force: true })
+    root = null
+  })
+
+  test('a LIVE supervisor .pid → live, with NO tmux session (the canary fix)', () => {
+    root = mkdtempSync(join(tmpdir(), 'iapeer-hostlive-'))
+    process.env.IAPEER_ROOT = root
+    const runDir = hostRunDir() // resolves under IAPEER_ROOT
+    mkdirSync(runDir, { recursive: true })
+    writeFileSync(join(runDir, 'codex-hostpeer.pid'), String(process.pid)) // a live pid = a live hosted daemon
+    expect(isPeerLive('codex', 'hostpeer')).toBe(true) // host-aware: no tmux, but the supervisor session is alive
+  })
+
+  test('no supervisor .pid and no tmux → offline', () => {
+    root = mkdtempSync(join(tmpdir(), 'iapeer-hostlive-'))
+    process.env.IAPEER_ROOT = root
+    mkdirSync(hostRunDir(), { recursive: true })
+    expect(isPeerLive('codex', 'ghostpeer')).toBe(false)
+  })
+
+  test('listOnlinePeers includes a live HOSTED peer (no tmux socket)', () => {
+    root = mkdtempSync(join(tmpdir(), 'iapeer-hostlive-'))
+    process.env.IAPEER_ROOT = root
+    const runDir = hostRunDir()
+    mkdirSync(runDir, { recursive: true })
+    // supervisor listSessions enumerates by `<identity>.sock`; alive = a live `<identity>.pid`.
+    writeFileSync(join(runDir, 'codex-hostpeer.sock'), '')
+    writeFileSync(join(runDir, 'codex-hostpeer.pid'), String(process.pid))
+    const online = listOnlinePeers()
+    expect(online.some(p => p.runtime === 'codex' && p.personality === 'hostpeer')).toBe(true)
+  })
+})

package/src/transport/index.ts

@@ -54,6 +54,7 @@ import {
   hostRunDir,
   hostSessionAlive,
   hostSessionToken,
+  listHostedPeers,
   HOST_COLS,
   HOST_ROWS,
 } from '../launch/ptyHost.ts'
@@ -113,7 +114,12 @@ function listSessions(sock: string): string[] {
 }
 
 function sessionAlive(sock: string, address: string): boolean {
-  return listSessions(sock).includes(address)
+  // SPAWN-FLIP Ф0b-3: a supervisor-HOSTED session has no tmux entry — its liveness is the supervisor
+  // daemon (runtime-state), checked FIRST (a cheap pid-file). Non-hosted → the tmux session list, as
+  // before (byte-identical). Without this, resolveDeliveryTarget/isPeerLive see a live hosted peer as
+  // OFFLINE → routeSend mis-routes a warm hit to a wake and the post-wake verify-before-act false-fails
+  // (the canary symptom: "woke but not live" though delivery actually landed). `address` IS the identity.
+  return hostSessionAlive(address) || listSessions(sock).includes(address)
 }
 
 // ─── Busy-composer detection (human input vs runtime ghost text) ─────────────
@@ -285,13 +291,13 @@ export function isPeerLive(runtime: string, personality: string, sockDir = resol
 }
 
 export function listOnlinePeers(sockDir = resolveSockDir()): OnlinePeer[] {
-  let entries: string[]
+  const out = new Map<string, OnlinePeer>()
+  let entries: string[] = []
   try {
     entries = readdirSync(sockDir)
   } catch {
-    return []
+    /* no tmux sock dir → only supervisor-hosted peers, merged below (never early-return past them) */
   }
-  const out = new Map<string, OnlinePeer>()
   for (const entry of entries) {
     const parsedSocket = parseSocketPath(join(sockDir, entry))
     if (!parsedSocket) continue
@@ -305,6 +311,11 @@ export function listOnlinePeers(sockDir = resolveSockDir()): OnlinePeer[] {
       })
     }
   }
+  // SPAWN-FLIP Ф0b-3: supervisor-HOSTED peers have no tmux socket, so the scan above misses them —
+  // merge in the live hosted sessions so the online scan + the no-runtime resolve see them too.
+  for (const h of listHostedPeers()) {
+    out.set(buildProcessAddress(h.runtime, h.personality), { personality: h.personality, runtime: h.runtime })
+  }
   return Array.from(out.values()).sort(
     (a, b) =>
       a.personality.localeCompare(b.personality) || a.runtime.localeCompare(b.runtime),