@agfpd/iapeer 0.2.77 → 0.2.79

package/src/supervisor/boot.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { codexAdapter } from '../launch/adapters/codex.ts'
-import { claudeAdapter } from '../launch/adapters/claude.ts'
-import { nextBootAction, type BootAction } from './boot.ts'
-
-// Fed the REAL runtime adapters (codexAdapter/claudeAdapter) — not fakes — so the test proves the
-// supervisor answers the exact dialogs the launch primitive answers, with byte-correct keys.
-const bytesOf = (a: BootAction): Buffer => (a.kind === 'dialog' ? a.bytes : Buffer.alloc(0))
-
-describe('nextBootAction — codex startup dialogs answered off the model', () => {
-  test('dir-trust → Enter (CR)', () => {
-    const a = nextBootAction(codexAdapter, 'Do you trust the contents of this directory?\n  1. Yes, continue')
-    expect(a.kind).toBe('dialog')
-    expect(bytesOf(a)).toEqual(Buffer.from('\r'))
-  })
-
-  test('update offer → decline [2,Enter], and NOT ready while "Press enter to continue" is up', () => {
-    const pane = 'Update available! 9.9.9\nPress enter to continue'
-    const a = nextBootAction(codexAdapter, pane)
-    expect(a.kind).toBe('dialog')
-    expect(bytesOf(a)).toEqual(Buffer.from('2\r'))
-  })
-
-  test('hooks-review → [Down,Enter]; the cursor byte follows the model cursor mode', () => {
-    const pane = 'Hooks need review\n  1. Review  2. Trust all and continue'
-    expect(bytesOf(nextBootAction(codexAdapter, pane))).toEqual(Buffer.from('\x1b[B\r')) // normal
-    expect(bytesOf(nextBootAction(codexAdapter, pane, { appCursorKeys: true }))).toEqual(Buffer.from('\x1bOB\r')) // DECCKM
-  })
-
-  test('composer rendered, no startup screen → ready', () => {
-    expect(nextBootAction(codexAdapter, 'a rotating tip line\n› ').kind).toBe('ready')
-  })
-
-  test('splash up, composer not yet rendered → wait', () => {
-    expect(nextBootAction(codexAdapter, 'OpenAI Codex\n(loading session)').kind).toBe('wait')
-  })
-})
-
-describe('nextBootAction — claude startup dialogs answered off the model', () => {
-  test('folder-trust → Enter (CR)', () => {
-    const a = nextBootAction(claudeAdapter, 'Do you trust this folder?\n  1. Yes')
-    expect(a.kind).toBe('dialog')
-    expect(bytesOf(a)).toEqual(Buffer.from('\r'))
-  })
-
-  test('resume-picker before the cursor reaches option 2 → Down (mode-correct cursor byte)', () => {
-    const pane = 'Resume from summary\n  ❯ 1. Start fresh\n    2. Resume full session'
-    const a = nextBootAction(claudeAdapter, pane)
-    expect(a.kind).toBe('dialog')
-    expect(bytesOf(a)).toEqual(Buffer.from('\x1b[B')) // normal cursor mode
-    expect(bytesOf(nextBootAction(claudeAdapter, pane, { appCursorKeys: true }))).toEqual(Buffer.from('\x1bOB'))
-  })
-
-  test('resume-picker once the cursor IS on option 2 → Enter (never re-Downs past the proceed row)', () => {
-    const pane = 'Resume from summary\n    1. Start fresh\n  ❯ 2. Resume full session'
-    expect(bytesOf(nextBootAction(claudeAdapter, pane))).toEqual(Buffer.from('\r'))
-  })
-
-  test('input row + bypass banner → ready', () => {
-    expect(nextBootAction(claudeAdapter, '❯ \n  bypass permissions on').kind).toBe('ready')
-  })
-
-  test('splash up, input row not yet rendered → wait', () => {
-    expect(nextBootAction(claudeAdapter, 'Welcome to Claude Code\n  (starting)').kind).toBe('wait')
-  })
-})

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

@@ -1,107 +0,0 @@
-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/daemon.test.ts

@@ -1,213 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { FRAME_DATA, FRAME_RESIZE, frame, makeFramer, sizePayload } from './protocol.ts'
-import { killSession, listSessions, sessionAlive, sockPath, startSupervisorDaemon } from './index.ts'
-
-// Integration: a REAL Bun-native pty daemon over a real unix socket, driven by the deterministic
-// `tick` runtime (no claude/codex needed) — hermetic (temp run dir, throwaway session). Proves
-// boris's Block-2 acceptance points: spawn + responder-served boot + attach repaint + live
-// forward + detach-survival + REATTACH FRESHNESS (the heavy-reattach bug the port-deps fixed).
-// 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 = 5000, step = 50): Promise<boolean> {
-  const end = Date.now() + timeoutMs
-  while (Date.now() < end) {
-    if (pred()) return true
-    await sleep(step)
-  }
-  return false
-}
-const maxTick = (s: string): number => {
-  let m = -1
-  for (const x of s.matchAll(/STREAMTICK_(\d+)/g)) m = Math.max(m, Number(x[1]))
-  return m
-}
-
-interface Client {
-  text(): string
-  close(): void
-}
-async function attach(runDir: string, session: string, cols = 80, rows = 24): Promise<Client> {
-  const frames: Buffer[] = []
-  const framer = makeFramer((t, p) => {
-    if (t === FRAME_DATA) frames.push(Buffer.from(p))
-  })
-  const sock = await Bun.connect({
-    unix: sockPath(runDir, session),
-    socket: {
-      open(s) {
-        s.write(frame(FRAME_RESIZE, sizePayload(cols, rows)))
-      },
-      data(_s, dd) {
-        framer(dd)
-      },
-    },
-  })
-  return {
-    text: () => Buffer.concat(frames).toString('latin1'),
-    close: () => {
-      try {
-        sock.end()
-      } catch {
-        /* */
-      }
-    },
-  }
-}
-
-d('supervisor daemon (Bun-native pty, tick runtime)', () => {
-  let runDir: string
-  const session = 'ptstest'
-
-  beforeAll(() => {
-    runDir = mkdtempSync(join(tmpdir(), 'iapeer-supervisor-'))
-  })
-  afterAll(() => {
-    try {
-      killSession(runDir, session)
-    } catch {
-      /* */
-    }
-    rmSync(runDir, { recursive: true, force: true })
-  })
-
-  test('spawns a detached daemon that comes up live', () => {
-    const r = startSupervisorDaemon({ session, runtime: 'tick', runDir })
-    expect(r.state).toBe('started')
-    expect(sessionAlive(runDir, session)).toBe(true)
-    expect(listSessions(runDir).some(s => s.session === session && s.alive)).toBe(true)
-  })
-
-  test('attach forwards live child output (the pty conduit works end-to-end)', async () => {
-    const c = await attach(runDir, session)
-    const got = await waitFor(() => /STREAMTICK_\d+/.test(c.text()))
-    expect(got).toBe(true) // live STREAMTICK_N stream reached the client
-    c.close()
-  })
-
-  test('detach keeps the daemon alive (detach-persistence)', async () => {
-    await sleep(150)
-    expect(sessionAlive(runDir, session)).toBe(true)
-  })
-
-  test('REATTACH repaints the CURRENT frame, not a stale one (port-dep #2 freshness)', async () => {
-    const first = await attach(runDir, session)
-    await waitFor(() => maxTick(first.text()) >= 0)
-    const base = maxTick(first.text())
-    first.close()
-    await sleep(800) // the stream advances while detached
-    const second = await attach(runDir, session)
-    // the reattach repaint (serialize of the CURRENT screen) must reflect ticks emitted AFTER the
-    // first detach — a stale close-moment frame would show base, not a higher index.
-    const fresh = await waitFor(() => maxTick(second.text()) > base, 5000)
-    expect(fresh).toBe(true)
-    second.close()
-  })
-
-  // Serving seam (slice b): a serve-spec is written before spawn, the detached daemon reads it, and
-  // the composed argv + env + cwd reach the child VERBATIM (with the pty-host TERM layered on top and
-  // TMUX stripped). A probe child dumps the markers it actually received — proving the supervisor
-  // serves a launch-composed invocation faithfully (the parity foundation; the env-identity ABI rides
-  // in here at serving time).
-  test('serving seam: composed argv + env + cwd reach the child verbatim (slice b)', async () => {
-    const servingSession = 'ptsserve'
-    const childCwd = realpathSync(mkdtempSync(join(tmpdir(), 'iapeer-serve-cwd-')))
-    const out = join(runDir, 'serve-probe.out')
-    try {
-      const serve = {
-        // dump what the child ACTUALLY received: a composed env var, its cwd, TERM, and TMUX-presence
-        argv: [
-          'sh',
-          '-c',
-          'printf "%s\\n%s\\n%s\\n%s\\n" "$SERVE_MARKER" "$(pwd -P)" "$TERM" "${TMUX:-no-tmux}" > "$OUTFILE"; exec sleep 30',
-        ],
-        env: { SERVE_MARKER: 'identity-abi-xyz', OUTFILE: out, PATH: process.env.PATH ?? '', TMUX: 'should-be-stripped' },
-        cwd: childCwd,
-      }
-      const r = startSupervisorDaemon({ session: servingSession, runtime: 'claude', runDir, serve })
-      expect(r.state).toBe('started')
-      const wrote = await waitFor(() => existsSync(out) && readFileSync(out, 'utf8').trim().split('\n').length >= 4)
-      expect(wrote).toBe(true)
-      const [marker, pwd, term, tmux] = readFileSync(out, 'utf8').split('\n')
-      expect(marker).toBe('identity-abi-xyz') // composed env reached the child verbatim
-      expect(pwd).toBe(childCwd) // composed cwd honored
-      expect(term).toBe('xterm-256color') // pty-host TERM layered on top of the composed env
-      expect(tmux).toBe('no-tmux') // TMUX stripped — a served child never thinks it is inside tmux
-    } finally {
-      killSession(runDir, servingSession)
-      rmSync(childCwd, { recursive: true, force: true })
-    }
-  })
-
-  // Exit-cause (spawn-flip Ф0b-1 resilience-b): when the hosted child dies, the daemon records a
-  // `ev=session-exit … host=supervisor` line in exits.log — the cause the supervise-tick death
-  // classification + crash-loop accounting need (mirror of the tmux pane-died hook). Kill the child,
-  // assert the line lands.
-  test('exit-cause: the daemon records the hosted child death in exits.log (resilience-b)', async () => {
-    const exSession = 'ptsexit'
-    const exitLog = join(runDir, 'exits.log')
-    const childPidFile = join(runDir, 'exit-child.pid')
-    try {
-      const r = startSupervisorDaemon({
-        session: exSession,
-        runtime: 'tick',
-        runDir,
-        serve: { argv: ['sh', '-c', `echo $$ > '${childPidFile}'; exec sleep 30`], env: { PATH: process.env.PATH ?? '' }, cwd: runDir, exitLogPath: exitLog },
-      })
-      expect(r.state).toBe('started')
-      const got = await waitFor(() => existsSync(childPidFile))
-      expect(got).toBe(true)
-      process.kill(Number(readFileSync(childPidFile, 'utf8').trim()), 'SIGKILL')
-      const recorded = await waitFor(() => existsSync(exitLog) && /ev=session-exit identity=ptsexit.*host=supervisor/.test(readFileSync(exitLog, 'utf8')))
-      expect(recorded).toBe(true) // the death cause is in exits.log → crash-loop accounting has it
-    } finally {
-      try {
-        killSession(runDir, exSession)
-      } catch {
-        /* */
-      }
-    }
-  })
-
-  // 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/deliver.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { deliverToHost } from './deliver.ts'
-import { killSession, startSupervisorDaemon } from './index.ts'
-
-// The deliver leaf is the host equivalent of tmux load-buffer/paste-buffer/send-keys: it must put the
-// message on the hosted child's pty input as a bracketed paste followed by a CR. Hermetic: a probe
-// child captures its raw stdin (stty raw bypasses the line discipline) so we assert the EXACT bytes
-// the child received. Guarded on Bun-native pty.
-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))
-
-d('deliverToHost (supervisor-socket delivery — bracketed paste + CR)', () => {
-  test('the child receives exactly: ESC[200~ <message> ESC[201~ CR', async () => {
-    const runDir = mkdtempSync(join(tmpdir(), 'iapeer-deliver-'))
-    const out = join(runDir, 'stdin.bin')
-    const msg = 'hello-deliver-❯'
-    const expected = `\x1b[200~${msg}\x1b[201~\r`
-    const n = Buffer.byteLength(expected, 'utf8')
-    try {
-      // probe child: raw mode (no line-discipline cooking), read exactly n bytes, dump to a file
-      const argv = ['sh', '-c', `stty raw -echo; head -c ${n} > '${out}'; sleep 5`]
-      const r = startSupervisorDaemon({ session: 'dlv', runtime: 'tick', runDir, serve: { argv, env: { PATH: process.env.PATH ?? '' }, cwd: runDir } })
-      expect(r.state).toBe('started')
-      await sleep(400) // let the probe reach raw mode
-      const res = await deliverToHost(runDir, 'dlv', msg)
-      expect(res.ok).toBe(true)
-      // wait for the child to have captured n bytes
-      const deadline = Date.now() + 3000
-      while (Date.now() < deadline && !(existsSync(out) && readFileSync(out).length >= n)) await sleep(50)
-      const got = existsSync(out) ? readFileSync(out) : Buffer.alloc(0)
-      expect(got.equals(Buffer.from(expected, 'utf8'))).toBe(true) // bracketed paste + CR, byte-exact
-    } finally {
-      try {
-        killSession(runDir, 'dlv')
-      } catch {
-        /* */
-      }
-      await sleep(300)
-      rmSync(runDir, { recursive: true, force: true })
-    }
-  })
-
-  test('no supervisor socket → a clean error, not a throw', async () => {
-    const runDir = mkdtempSync(join(tmpdir(), 'iapeer-deliver-none-'))
-    try {
-      const res = await deliverToHost(runDir, 'nope', 'x')
-      expect(res.ok).toBe(false)
-      expect(res.error).toContain('no supervisor socket')
-    } finally {
-      rmSync(runDir, { recursive: true, force: true })
-    }
-  })
-})

package/src/supervisor/panelog.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { spawnSync } from 'node:child_process'
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { Terminal } from '@xterm/headless'
-import { modelToPlainText } from '../shadow/render.ts'
-import { killSession, startSupervisorDaemon } from './index.ts'
-
-// Slice c — the supervisor pane-log must be a drop-in for tmux pipe-pane: the SAME raw child bytes to
-// <identity>.log (so observer/shadow/readyGateViewport read a served session identically), AND a model
-// built from it must render what tmux's capture-pane shows. Live tmux + Bun-native pty → guarded.
-const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0
-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 = tmuxAvailable && bunPty ? describe : describe.skip
-
-const sleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms))
-const readBuf = (p: string): Buffer => (existsSync(p) ? readFileSync(p) : Buffer.alloc(0))
-const modelOf = (bytes: Buffer, cols: number, rows: number): Promise<string> => {
-  const t = new Terminal({ cols, rows, allowProposedApi: true, scrollback: 1000 })
-  return new Promise<string>(res => t.write(bytes, () => res(modelToPlainText(t, cols, rows))))
-}
-
-d('supervisor pane-log ≡ tmux pipe-pane', () => {
-  test('RAW-BYTE-IDENTITY: the same child yields byte-identical logs (LF/CRLF + multibyte + ANSI)', async () => {
-    const dir = mkdtempSync(join(tmpdir(), 'panelog-bp-'))
-    const tmuxSock = join(dir, 't.sock')
-    const logTmux = join(dir, 'tmux.log')
-    const logSup = join(dir, 'sup.log')
-    const runDir = join(dir, 'run')
-    // bare \n, \r\n, multibyte ❯ › … é (the latin1 grabli), ANSI SGR — the byte classes that diverge
-    const child = ['sh', '-c', `sleep 0.5; printf 'L1\\nL2\\r\\ng:❯›…é\\n\\033[31mRED\\033[0m\\nTAB\\tEND\\n'; sleep 1`]
-    try {
-      spawnSync('tmux', ['-S', tmuxSock, 'new-session', '-d', '-s', 'p', '-x', '80', '-y', '24', ...child], { stdio: 'ignore' })
-      spawnSync('tmux', ['-S', tmuxSock, 'pipe-pane', '-o', '-t', 'p', `cat >> '${logTmux}'`], { stdio: 'ignore' })
-      startSupervisorDaemon({ session: 'bp', runtime: 'tick', runDir, serve: { argv: child, env: { PATH: process.env.PATH ?? '' }, cwd: dir, paneLogPath: logSup } })
-      await sleep(2300) // both children: sleep .5 + emit + sleep 1 ≈ exit ~1.5s; tmux's cat EOF-flushes
-      const a = readBuf(logTmux)
-      const b = readBuf(logSup)
-      expect(b.length).toBeGreaterThan(0)
-      expect(b.equals(a)).toBe(true) // byte-for-byte — raw Buffer passthrough, shared onlcr default
-      expect(b.includes(Buffer.from('❯›…é', 'utf8'))).toBe(true) // multibyte survived (no latin1 re-encode)
-    } finally {
-      spawnSync('tmux', ['-S', tmuxSock, 'kill-server'], { stdio: 'ignore' })
-      try {
-        killSession(runDir, 'bp')
-      } catch {
-        /* */
-      }
-      await sleep(300)
-      rmSync(dir, { recursive: true, force: true })
-    }
-  })
-
-  test('BINDING: a model from the supervisor pane-log renders what tmux capture-pane shows', async () => {
-    const dir = mkdtempSync(join(tmpdir(), 'panelog-bind-'))
-    const tmuxSock = join(dir, 't.sock')
-    const logSup = join(dir, 'sup.log')
-    const runDir = join(dir, 'run')
-    const COLS = 80,
-      ROWS = 24
-    // a static frame (clear+home, three lines incl. the ❯ ready glyph), then idle so capture-pane sees it
-    const child = ['sh', '-c', `printf '\\033[2J\\033[HLine one\\r\\n  ❯ ready prompt\\r\\nthird line ok\\r\\n'; sleep 30`]
-    try {
-      spawnSync('tmux', ['-S', tmuxSock, 'new-session', '-d', '-s', 'b', '-x', String(COLS), '-y', String(ROWS), ...child], { stdio: 'ignore' })
-      startSupervisorDaemon({ session: 'bind', runtime: 'tick', runDir, serve: { argv: child, env: { PATH: process.env.PATH ?? '' }, cwd: dir, paneLogPath: logSup } })
-      // let the frame render in both
-      let cap = ''
-      for (let i = 0; i < 30 && !/❯ ready prompt/.test(cap); i++) {
-        await sleep(200)
-        cap = spawnSync('tmux', ['-S', tmuxSock, 'capture-pane', '-p', '-t', 'b'], { encoding: 'utf8' }).stdout || ''
-      }
-      const modelSup = await modelOf(readBuf(logSup), COLS, ROWS)
-      // tmux capture-pane render (its own emulator) == @xterm model of the SUPERVISOR's pane-log
-      const norm = (s: string): string =>
-        s
-          .split('\n')
-          .map(l => l.replace(/\s+$/, ''))
-          .join('\n')
-          .replace(/\n+$/, '')
-      expect(norm(modelSup)).toBe(norm(cap))
-      expect(modelSup).toContain('❯ ready prompt') // the ready glyph survived into the model
-    } finally {
-      spawnSync('tmux', ['-S', tmuxSock, 'kill-server'], { stdio: 'ignore' })
-      try {
-        killSession(runDir, 'bind')
-      } catch {
-        /* */
-      }
-      await sleep(300)
-      rmSync(dir, { recursive: true, force: true })
-    }
-  })
-})