@agfpd/iapeer 0.2.69 → 0.2.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.69",
+  "version": "0.2.71",
   "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/daemon.test.ts

@@ -174,4 +174,40 @@ d('supervisor daemon (Bun-native pty, tick runtime)', () => {
       }
     }
   })
+
+  // FINDING-2 — restore the SERVE geometry on last detach. The daemon resizes the child pty to a
+  // client's size on attach and (before this) never restored it, so an unattached session stuck at a
+  // departed client's size → the fixed-geometry warm-deliver/ready-gate viewport model mismatched the
+  // pty. Drive it with a child that prints its live pty winsize ("ROWS COLS") to the pane-log: attach
+  // small → pty shrinks; detach → pty restores to the serve geometry.
+  test('FINDING-2: last detach restores the serve geometry (no sticking at the client size)', async () => {
+    const gSession = 'ptsgeo'
+    const paneLog = join(runDir, 'geo-pane.log')
+    const lastSize = (): string => {
+      const t = existsSync(paneLog) ? readFileSync(paneLog, 'utf8') : ''
+      const m = [...t.matchAll(/(\d+) (\d+)/g)]
+      return m.length ? `${m[m.length - 1][1]}x${m[m.length - 1][2]}` : ''
+    }
+    try {
+      const r = startSupervisorDaemon({
+        session: gSession,
+        runtime: 'tick',
+        runDir,
+        // serve geometry 200x50 (distinct from defaults); child reports its live pty winsize as "rows cols"
+        serve: { argv: ['sh', '-c', 'while :; do stty size 2>/dev/null; sleep 0.3; done'], env: { PATH: process.env.PATH ?? '' }, cwd: runDir, paneLogPath: paneLog, cols: 200, rows: 50 },
+      })
+      expect(r.state).toBe('started')
+      expect(await waitFor(() => lastSize() === '50 200'.replace(' ', 'x'), 6000)).toBe(true) // at serve geometry
+      const c = await attach(runDir, gSession, 90, 30) // attach at a DIFFERENT size → pty resizes to it
+      expect(await waitFor(() => lastSize() === '30x90', 6000)).toBe(true) // pty shrank to the client size
+      c.close() // last client gone
+      expect(await waitFor(() => lastSize() === '50x200', 6000)).toBe(true) // RESTORED to serve geometry
+    } finally {
+      try {
+        killSession(runDir, gSession)
+      } catch {
+        /* */
+      }
+    }
+  })
 })

package/src/supervisor/daemon.ts

@@ -90,6 +90,13 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
   const { session, runtime, runDir } = opts
   let cols = opts.cols ?? 80
   let rows = opts.rows ?? 30
+  // The SERVE geometry — the size the session is hosted at (HOST_COLS×HOST_ROWS for a pty-host peer),
+  // immutable. `cols`/`rows` above track the CURRENT (client-driven) size. A client attaches at its own
+  // terminal size and the pty resizes to match; on LAST detach we restore the serve geometry (below) so
+  // the unattached session never sticks at a departed client's size — otherwise the warm-deliver /
+  // ready-gate viewport model (built at the fixed serve geometry) mismatches the actually-resized pty.
+  const serveCols = cols
+  const serveRows = rows
   const sock = sockPath(runDir, session)
   const pid = pidPath(runDir, session)
 
@@ -217,28 +224,40 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
     sendClient(s, frame(FRAME_DATA, Buffer.from(snap, 'utf8')))
   }
 
+  // Resize the model + child pty to (c, r). Shared by client FRAME_RESIZE and the last-detach restore.
+  const applyGeometry = (c: number, r: number): void => {
+    cols = c
+    rows = r
+    try {
+      xterm.resize(c, r)
+      child.terminal.resize(c, r)
+    } catch {
+      /* transient */
+    }
+    // Best-effort SIGWINCH nudge for a SIGWINCH-reactive child (forces a repaint at the new size); NOT
+    // load-bearing for an attached client (the complete snapshot repaint is), but for the unattached
+    // restore it is what makes the child redraw into the pane-log at the serve geometry.
+    try {
+      child.terminal.resize(c, Math.max(1, r - 1))
+      child.terminal.resize(c, r)
+    } catch {
+      /* */
+    }
+  }
+  // Restore the serve geometry when the last client detaches, so the unattached session never sticks at
+  // a departed client's size (FINDING-2 — would mismatch the fixed-geometry warm-deliver/ready-gate
+  // viewport model). No-op when already at serve geometry or a client is still attached.
+  const restoreServeGeometryIfIdle = (): void => {
+    if (clients.size === 0 && (cols !== serveCols || rows !== serveRows)) applyGeometry(serveCols, serveRows)
+  }
+
   const onClientFrame = (s: { write(b: Buffer): number }, type: number, payload: Buffer): void => {
     if (type === FRAME_DATA) {
       child.terminal.write(payload) // keystrokes → child
     } else if (type === FRAME_RESIZE) {
       const sz = parseSize(payload)
-      cols = sz.cols
-      rows = sz.rows
-      try {
-        xterm.resize(cols, rows)
-        child.terminal.resize(cols, rows)
-      } catch {
-        /* transient */
-      }
+      applyGeometry(sz.cols, sz.rows)
       repaint(s) // instant paint from the snapshot (delivered COMPLETE via backpressure)
-      // Best-effort SIGWINCH nudge for a SIGWINCH-reactive child; NOT load-bearing (the complete
-      // snapshot above is the real freshness fix).
-      try {
-        child.terminal.resize(cols, Math.max(1, rows - 1))
-        child.terminal.resize(cols, rows)
-      } catch {
-        /* */
-      }
     }
   }
 
@@ -266,11 +285,13 @@ export function runSupervisorDaemon(opts: SupervisorDaemonOptions): void {
         clients.delete(s)
         writers.delete(s)
         syncAttached()
+        restoreServeGeometryIfIdle() // last client gone → un-stick the pty from its size
       },
       error(s: object) {
         clients.delete(s)
         writers.delete(s)
         syncAttached()
+        restoreServeGeometryIfIdle()
       },
     },
   })