@agfpd/iapeer 0.2.66 → 0.2.68

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.66",
+  "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/supervisor/index.ts

@@ -76,13 +76,15 @@ export interface StartDaemonResult {
  * re-invoke the installed binary through its `supervisor` verb instead. The caller appends
  * `daemon <session> <runtime> --run-dir <dir>`, so runSupervisorCli is reached either way.
  */
-export function resolveDaemonSelfArgv(execPath: string, selfPath: string, selfOnDisk: boolean): string[] {
-  return selfOnDisk ? [execPath, selfPath] : [execPath, 'supervisor']
-}
-const selfArgv = (): string[] => {
-  const self = fileURLToPath(import.meta.url)
-  return resolveDaemonSelfArgv(process.execPath, self, existsSync(self))
+export function resolveDaemonSelfArgv(execPath: string, selfPath: string): string[] {
+  // A `bun build --compile` standalone embeds this module at a `/$bunfs/root/…` virtual path
+  // (verified: import.meta.url → file:///$bunfs/root/…). `existsSync` is NO discriminator — Bun
+  // intercepts bunfs reads so it is true for BOTH src and compiled. The `$bunfs` marker in the self
+  // path IS the discriminator: compiled → re-invoke the installed binary through its `supervisor` verb
+  // (the caller appends `daemon …`); source → a real on-disk file, run it directly via the runtime.
+  return selfPath.includes('$bunfs') ? [execPath, 'supervisor'] : [execPath, selfPath]
 }
+const selfArgv = (): string[] => resolveDaemonSelfArgv(process.execPath, fileURLToPath(import.meta.url))
 
 /** Start a detached supervisor daemon and wait until its socket is live. Idempotent. */
 export function startSupervisorDaemon(opts: StartDaemonOptions): StartDaemonResult {

package/src/supervisor/selfargv.test.ts

@@ -7,15 +7,16 @@ import { describe, expect, test } from 'bun:test'
 import { resolveDaemonSelfArgv } from './index.ts'
 
 describe('resolveDaemonSelfArgv', () => {
-  test('source (self on disk) → re-run the module directly with the runtime (bun)', () => {
-    expect(resolveDaemonSelfArgv('/opt/homebrew/bin/bun', '/Users/x/iapeer/src/supervisor/index.ts', true))
-      .toEqual(['/opt/homebrew/bin/bun', '/Users/x/iapeer/src/supervisor/index.ts'])
+  // Paths are the EMPIRICALLY-verified shapes: bun → real /private/... file; compiled → /$bunfs/root/...
+  test('source (real on-disk module) → re-run the module directly via the runtime (bun)', () => {
+    expect(resolveDaemonSelfArgv('/Users/x/.bun/bin/bun', '/Users/x/iapeer/src/supervisor/index.ts'))
+      .toEqual(['/Users/x/.bun/bin/bun', '/Users/x/iapeer/src/supervisor/index.ts'])
   })
 
-  test('compiled standalone (self NOT on disk = embedded /$bunfs) → installed binary + `supervisor` verb', () => {
-    expect(resolveDaemonSelfArgv('/Users/x/.local/bin/iapeer', '/$bunfs/root/src/supervisor/index.ts', false))
+  test('compiled standalone (embedded /$bunfs path) → installed binary + `supervisor` verb', () => {
+    expect(resolveDaemonSelfArgv('/Users/x/.local/bin/iapeer', '/$bunfs/root/src/supervisor/index.ts'))
       .toEqual(['/Users/x/.local/bin/iapeer', 'supervisor'])
     // The caller appends `daemon <session> <runtime> --run-dir <dir>` → `iapeer supervisor daemon …`,
-    // which the CLI routes to runSupervisorCli('daemon', …). NOT a bare bunfs-path (→ usage).
+    // which the CLI routes to runSupervisorCli('daemon', …). NOT a bare bunfs-path (→ usage dump).
   })
 })

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