@agfpd/iapeer 0.2.68 → 0.2.70

package/package.json

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

package/src/launch/invocation.test.ts

@@ -107,6 +107,46 @@ describe('buildLaunchInvocation — differential vs the verbatim pre-extraction
   })
 })
 
+// Silent-loss guard — the claude-hosting canary caught a warm-deliver false-fail: a launch INITIATED
+// from inside a claude session leaked CLAUDE_CODE_SESSION_ID + CLAUDE_CODE_CHILD_SESSION into the
+// child, which then wrote no own transcript → newestActivityMtime null → landed-confirm blind while
+// the message landed. buildLaunchInvocation must strip the claude-code-internal namespace so a
+// launched claude is always a FRESH top-level session, regardless of initiator env.
+describe('buildLaunchInvocation — strips the claude-code-internal session namespace', () => {
+  const DIRTY: LaunchAdapterConfig & { env: NodeJS.ProcessEnv } = {
+    claudeBin: '/bin/claude',
+    codexBin: '/bin/codex',
+    env: {
+      PATH: '/test/path',
+      BASE_VAR: 'base',
+      CLAUDE_CODE_SESSION_ID: 'spawner-session-uuid', // the corruptor (pins the child to the spawner's session)
+      CLAUDE_CODE_CHILD_SESSION: '1', // the corruptor (marks a child sub-session → suppresses own transcript)
+      CLAUDECODE: '1',
+      CLAUDE_CODE_ENTRYPOINT: 'cli',
+      CLAUDE_CODE_EXECPATH: '/v/2.1.177',
+      CLAUDE_EFFORT: 'xhigh', // NOT in the claude-code namespace → must survive (scoped strip, not a wipe)
+    },
+  }
+  test('claude launch: the whole CLAUDE_CODE_* namespace + CLAUDECODE is removed', () => {
+    const { env } = buildLaunchInvocation(spec({ runtime: 'claude', identity: 'claude-p' }), claudeAdapter, DIRTY)
+    expect(env.CLAUDE_CODE_SESSION_ID).toBeUndefined()
+    expect(env.CLAUDE_CODE_CHILD_SESSION).toBeUndefined()
+    expect(env.CLAUDECODE).toBeUndefined()
+    expect(env.CLAUDE_CODE_ENTRYPOINT).toBeUndefined()
+    expect(env.CLAUDE_CODE_EXECPATH).toBeUndefined()
+    // scoped: non-namespace vars (incl. a CLAUDE_-prefixed-but-not-CLAUDE_CODE_ one) survive
+    expect(env.BASE_VAR).toBe('base')
+    expect(env.CLAUDE_EFFORT).toBe('xhigh')
+    expect(env.PEER_IDENTITY).toBe('claude-p')
+  })
+  test('codex launch: same strip applies (harmless — codex ignores CLAUDE_*) and the bearer stub stays', () => {
+    const { env } = buildLaunchInvocation(spec({ runtime: 'codex', identity: 'codex-p' }), codexAdapter, DIRTY)
+    expect(env.CLAUDE_CODE_SESSION_ID).toBeUndefined()
+    expect(env.CLAUDECODE).toBeUndefined()
+    expect(env[CODEX_BEARER_ENV_VAR]).toBe(CODEX_DUMMY_BEARER)
+  })
+})
+
 // Independent contract anchors — expectations come from the CONTRACT, not from the function output.
 describe('buildLaunchInvocation — identity ABI + system-prompt swap (contract values)', () => {
   test('codex carries the non-secret IAPEER_BEARER stub; claude does NOT (identity in .mcp.json)', () => {

package/src/launch/invocation.ts

@@ -52,5 +52,20 @@ export function buildLaunchInvocation(
     PEER_IDENTITY: spec.identity,
     PATH: env.PATH ?? `${homedir()}/.bun/bin:${homedir()}/.local/bin:/opt/homebrew/bin:/usr/bin:/bin`,
   }
+  // Strip the claude-code-internal session namespace from the inherited env. When a launch is
+  // INITIATED from inside a running claude session (an operator CLI, or a claude peer shelling out),
+  // process.env carries that session's CLAUDE_CODE_SESSION_ID + CLAUDE_CODE_CHILD_SESSION. Inherited
+  // by a newly-launched claude, they make it believe it is a CHILD sub-session of the initiator → it
+  // writes NO independent ~/.claude/projects transcript → newestActivityMtime(cwd) is permanently
+  // null → the warm-deliver landed-confirm false-fails WHILE the message actually lands (a silent-
+  // loss, the class the contract forbids). Stripping the whole namespace makes a launched claude
+  // always start as a FRESH top-level session (it re-establishes its own vars), independent of who
+  // initiated the launch — the env-composition analogue of the supervisor's TMUX strip. Caught live
+  // by the claude-hosting canary. Harmless for codex (no CLAUDE_* usage). NOTE: a launch driven by
+  // the always-on daemon already has a clean env (no claude session) — this hardens the CLI / peer-
+  // initiated paths and removes the silent-loss class regardless of initiator.
+  for (const k of Object.keys(childEnv)) {
+    if (k.startsWith('CLAUDE_CODE_') || k === 'CLAUDECODE') delete childEnv[k]
+  }
   return { argv, env: childEnv }
 }

package/src/supervisor/client.attach.test.ts

@@ -0,0 +1,107 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { killSession, sessionAlive, startSupervisorDaemon } from './index.ts'
+
+// SURFACE-5 regression — the interactive attach-and-stay loop. The other supervisor tests attach a
+// RAW socket; none drives the real `runSupervisorClient` under a TTY, so the canary's first live
+// `iapeer attach` exposed a bug invisible to them: runSupervisorClient resolved its Promise the
+// instant Bun.connect returned (setup done), the CLI caller ran `await runSupervisorClient(); return
+// 0` → runCli's `.then(process.exit)`, and the just-attached client was torn down within
+// milliseconds (handshake-then-exit). The fix makes the client BLOCK (never-resolve) after setup so
+// process.exit from a terminal path owns termination — exactly the detached `daemon` case's guard.
+//
+// This is the headless verifier of that fix AND the missing surface-5 automation: allocate a REAL
+// Bun-native pty, run the actual client CLI in it, assert it STAYS attached + renders live frames +
+// Ctrl-] detaches cleanly while the session keeps running. Arthur's live attach is the final human
+// seal; this test makes every iteration of the fix verifiable WITHOUT pulling him in.
+// Gated on Bun-native PTY (≥1.3.5) so a runner without it skips rather than reds.
+const [maj, min, pat] = (Bun.version || '0.0.0').split('.').map(Number) as [number, number, number]
+const bunPty = maj > 1 || (maj === 1 && (min > 3 || (min === 3 && pat >= 5)))
+const d = bunPty ? describe : describe.skip
+
+const sleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms))
+async function waitFor(pred: () => boolean, timeoutMs = 4000, step = 50): Promise<boolean> {
+  const end = Date.now() + timeoutMs
+  while (Date.now() < end) {
+    if (pred()) return true
+    await sleep(step)
+  }
+  return false
+}
+
+// Spawn the real attach client under a real pty (its stdin/stdout is a TTY → raw-mode path runs).
+interface PtyClient {
+  out(): string
+  exited(): boolean
+  sendKey(byte: number): void
+}
+function spawnAttachClient(runDir: string, session: string): PtyClient {
+  let buf = ''
+  let done = false
+  const proc = Bun.spawn(['bun', 'src/supervisor/index.ts', 'attach', session, '--run-dir', runDir], {
+    cwd: process.cwd(),
+    env: { ...process.env },
+    // a real Bun-native pty pair: the client sees a TTY on stdin (isTTY → setRawMode runs).
+    terminal: {
+      cols: 80,
+      rows: 24,
+      name: 'xterm-256color',
+      data(_t: unknown, data: Uint8Array | string) {
+        buf += Buffer.from(data as Uint8Array).toString('latin1')
+      },
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Bun pty spawn opts not yet in @types
+  } as any)
+  proc.exited.then(() => {
+    done = true
+  })
+  return {
+    out: () => buf,
+    exited: () => done,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- proc.terminal is the pty master writer
+    sendKey: (byte: number) => void (proc as any).terminal.write(Buffer.from([byte])),
+  }
+}
+
+d('runSupervisorClient interactive attach (surface-5, Bun-native pty)', () => {
+  let runDir: string
+  const session = 'ptsattach'
+
+  beforeAll(() => {
+    runDir = mkdtempSync(join(tmpdir(), 'iapeer-attach-'))
+    startSupervisorDaemon({ session, runtime: 'tick', runDir })
+  })
+  afterAll(() => {
+    try {
+      killSession(runDir, session)
+    } catch {
+      /* */
+    }
+    rmSync(runDir, { recursive: true, force: true })
+  })
+
+  test('the client STAYS attached after the handshake and keeps rendering live frames', async () => {
+    expect(sessionAlive(runDir, session)).toBe(true)
+    const c = spawnAttachClient(runDir, session)
+
+    // handshake: the attach line lands (connect + attach + terminal-setup succeeded).
+    expect(await waitFor(() => /\[supervisor\] attached to/.test(c.out()))).toBe(true)
+
+    // THE BUG was a handshake-then-exit within ~ms. Assert the client is STILL attached well past
+    // that window AND that live child output (STREAMTICK from the tick runtime) is reaching it —
+    // proving the attach-and-stay loop holds, not just that the process happens to linger.
+    await sleep(2000)
+    expect(c.exited()).toBe(false) // RED on the pre-fix early-resolve (exited ~ms after handshake)
+    expect(/STREAMTICK_\d+/.test(c.out())).toBe(true) // live frames flow through the held attach
+
+    // Ctrl-] (0x1d) detaches: the client exits cleanly, prints the DETACH message (not the
+    // misleading "session ended"), and the session keeps running.
+    c.sendKey(0x1d)
+    expect(await waitFor(() => c.exited())).toBe(true)
+    expect(/detached/.test(c.out())).toBe(true)
+    expect(/session ended/.test(c.out())).toBe(false) // detach must not claim the session ended
+    expect(sessionAlive(runDir, session)).toBe(true) // detach kept the daemon alive
+  })
+})

package/src/supervisor/client.ts

@@ -29,6 +29,10 @@ export async function runSupervisorClient(runDir: string, session: string): Prom
     process.exit(1)
   }
   let restored = false
+  // Set the instant a deliberate Ctrl-] detach begins. `sock.end()` can re-enter the socket close()
+  // handler synchronously, so close() must NOT claim "session ended" on an operator-initiated detach
+  // (the session keeps running) — it stays silent and lets the detach path own the message + exit.
+  let detaching = false
   // writeSync(1, …) works inside a signal handler (no event-loop dependency) — so a
   // SIGHUP/window-close client still resets the terminal before it dies (port-dep #1).
   const restore = (): void => {
@@ -70,6 +74,7 @@ export async function runSupervisorClient(runDir: string, session: string): Prom
       },
       close() {
         restore()
+        if (detaching) process.exit(0) // operator detached; the detach path already wrote its message
         process.stdout.write('\r\n[supervisor] session ended.\r\n')
         process.exit(0)
       },
@@ -82,13 +87,16 @@ export async function runSupervisorClient(runDir: string, session: string): Prom
 
   process.stdin.on('data', b => {
     if (b.includes(DETACH)) {
+      detaching = true
       restore()
+      // Write the detach message BEFORE sock.end() — sock.end() can re-enter close() synchronously,
+      // and close() now exits silently while `detaching`, so the message must already be out.
+      process.stdout.write(`\r\n[supervisor] detached — session still running. reattach: supervisor attach ${session}\r\n`)
       try {
         sock.end()
       } catch {
         /* */
       }
-      process.stdout.write(`\r\n[supervisor] detached — session still running. reattach: supervisor attach ${session}\r\n`)
       process.exit(0)
     }
     sock.write(frame(FRAME_DATA, b))
@@ -115,4 +123,11 @@ export async function runSupervisorClient(runDir: string, session: string): Prom
   }
   process.on('exit', () => restore()) // last-resort sync net
   process.stdout.write(`\x1b[2m[supervisor] attached to "${session}". detach: Ctrl-]  (session keeps running)\x1b[0m\r\n`)
+  // STAY ATTACHED. The client lives on its handles (raw stdin + the socket); EVERY terminal path
+  // (detach Ctrl-], session-end close(), SIGHUP/SIGTERM, socket error) calls process.exit ITSELF.
+  // This promise INTENTIONALLY never resolves: returning here would resolve runSupervisorClient the
+  // instant the handshake completed, and the CLI caller (`await runSupervisorClient(); return 0` →
+  // runCli's `.then(process.exit)`) would tear the just-attached client down in milliseconds — the
+  // surface-5 interactive-attach bug. The detached `daemon` case guards itself the same way.
+  await new Promise<never>(() => {})
 }