@agfpd/iapeer 0.2.76 → 0.2.78

package/src/supervisor/protocol.test.ts

@@ -1,222 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { spawnSync } from 'node:child_process'
-import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import {
-  BackpressureWriter,
-  FRAME_DATA,
-  FRAME_RESIZE,
-  TERM_RESET,
-  capabilityResponses,
-  frame,
-  keysToBytes,
-  makeFramer,
-  parseSize,
-  sizePayload,
-  stripQueries,
-} from './protocol.ts'
-
-const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0
-
-describe('frame protocol', () => {
-  test('frame() lays out [type][len:u32be][payload]', () => {
-    const f = frame(FRAME_DATA, 'hi')
-    expect(f[0]).toBe(FRAME_DATA)
-    expect(f.readUInt32BE(1)).toBe(2)
-    expect(f.subarray(5).toString()).toBe('hi')
-  })
-
-  test('makeFramer reassembles a frame split across chunk boundaries', () => {
-    const got: Array<{ t: number; p: string }> = []
-    const fr = makeFramer((t, p) => got.push({ t, p: p.toString() }))
-    const f = frame(FRAME_DATA, 'hello world')
-    fr(f.subarray(0, 3)) // partial header
-    fr(f.subarray(3, 8)) // rest of header + part of payload
-    expect(got).toHaveLength(0) // nothing complete yet
-    fr(f.subarray(8)) // tail
-    expect(got).toEqual([{ t: FRAME_DATA, p: 'hello world' }])
-  })
-
-  test('makeFramer splits multiple coalesced frames', () => {
-    const got: string[] = []
-    const fr = makeFramer((_t, p) => got.push(p.toString()))
-    fr(Buffer.concat([frame(FRAME_DATA, 'a'), frame(FRAME_DATA, 'bb'), frame(FRAME_DATA, 'ccc')]))
-    expect(got).toEqual(['a', 'bb', 'ccc'])
-  })
-
-  test('sizePayload/parseSize round-trip', () => {
-    expect(parseSize(sizePayload(132, 50))).toEqual({ cols: 132, rows: 50 })
-    expect(frame(FRAME_RESIZE, sizePayload(80, 24))[0]).toBe(FRAME_RESIZE)
-  })
-})
-
-describe('capability responder (the queries @xterm does not auto-answer)', () => {
-  test('secondary-DA-style XTVERSION query → version report', () => {
-    expect(capabilityResponses('\x1b[>0q')).toEqual(['\x1bP>|iapeer-pts(0.1)\x1b\\'])
-  })
-  test('OSC-11 theme query → an rgb background report', () => {
-    expect(capabilityResponses('\x1b]11;?\x07')[0]).toContain('\x1b]11;rgb:')
-  })
-  test('secondary DA (>c) → a DA2 report', () => {
-    expect(capabilityResponses('\x1b[>0c')).toEqual(['\x1b[>0;276;0c'])
-  })
-  test('plain output → no responses', () => {
-    expect(capabilityResponses('just some text\r\n')).toEqual([])
-  })
-  test('stripQueries removes DA1/DSR/theme but keeps real output', () => {
-    const s = 'before\x1b[0c\x1b[6nmid\x1b]11;?\x07after'
-    const out = stripQueries(s)
-    expect(out).toBe('beforemidafter')
-    expect(out).not.toContain('\x1b[6n')
-  })
-})
-
-describe('TERM_RESET (port-dep #1: clean every client exit path)', () => {
-  test('resets the leak-prone app-modes', () => {
-    expect(TERM_RESET).toContain('\x1b[?1049l') // leave alt-screen
-    expect(TERM_RESET).toContain('\x1b[?1000l') // mouse tracking off
-    expect(TERM_RESET).toContain('\x1b[?25h') // show cursor
-    expect(TERM_RESET).toContain('\x1b[<u') // pop kitty-keyboard
-  })
-})
-
-describe('BackpressureWriter (port-dep #2: the ~90 KB-over-8 KB truncation that staled reattach)', () => {
-  test('a fully-accepted write leaves nothing queued', () => {
-    const w = new BackpressureWriter(b => b.length)
-    expect(w.send(Buffer.alloc(100))).toBe(true)
-    expect(w.queuedBytes).toBe(0)
-  })
-
-  test('a heavy frame past the socket buffer is QUEUED, then fully delivered across drains', () => {
-    const CAP = 8192
-    let delivered = 0
-    const w = new BackpressureWriter(b => {
-      const n = Math.min(CAP, b.length)
-      delivered += n
-      return n
-    })
-    const heavy = Buffer.alloc(89305, 0x41) // the measured heavy-claude serialize size
-    expect(w.send(heavy)).toBe(true)
-    expect(delivered).toBe(CAP) // first write took only the socket buffer
-    expect(w.queuedBytes).toBe(89305 - CAP) // the rest is queued, NOT dropped
-    let guard = 0
-    while (w.queuedBytes > 0 && guard++ < 1000) w.flush() // drain events
-    expect(delivered).toBe(89305) // every byte eventually delivered (no truncation)
-    expect(w.queuedBytes).toBe(0)
-    expect(w.isDead).toBe(false)
-  })
-
-  test('coalesces a new send onto the pending tail (ordering preserved)', () => {
-    const CAP = 4
-    const chunks: string[] = []
-    const w = new BackpressureWriter(b => {
-      const n = Math.min(CAP, b.length)
-      chunks.push(b.subarray(0, n).toString())
-      return n
-    })
-    w.send(Buffer.from('ABCDEF')) // 'ABCD' written, 'EF' queued
-    w.send(Buffer.from('GH')) // coalesced onto 'EF' → 'EFGH'
-    let guard = 0
-    while (w.queuedBytes > 0 && guard++ < 100) w.flush()
-    expect(chunks.join('')).toBe('ABCDEFGH')
-  })
-
-  test('a dead socket (write throws) → send returns false and the writer is dead', () => {
-    const w = new BackpressureWriter(() => {
-      throw new Error('EPIPE')
-    })
-    expect(w.send(Buffer.alloc(10))).toBe(false)
-    expect(w.isDead).toBe(true)
-  })
-
-  test('a negative write count → dead', () => {
-    const w = new BackpressureWriter(() => -1)
-    expect(w.send(Buffer.alloc(10))).toBe(false)
-    expect(w.isDead).toBe(true)
-  })
-})
-
-describe('keysToBytes (tmux send-keys vocabulary → pty bytes, the boot key-set)', () => {
-  test('Enter → CR (the trust/proceed dialogs)', () => {
-    expect(keysToBytes(['Enter'])).toEqual(Buffer.from('\r'))
-  })
-  test('codex update-decline [2,Enter] → "2" + CR', () => {
-    expect(keysToBytes(['2', 'Enter'])).toEqual(Buffer.from('2\r'))
-  })
-  test('codex hooks-review [Down,Enter] in NORMAL cursor mode → CSI-B + CR', () => {
-    expect(keysToBytes(['Down', 'Enter'])).toEqual(Buffer.from('\x1b[B\r'))
-  })
-  test('[Down,Enter] under DECCKM application-cursor mode → SS3-B + CR (the mode-sensitivity boris flagged)', () => {
-    expect(keysToBytes(['Down', 'Enter'], { appCursorKeys: true })).toEqual(Buffer.from('\x1bOB\r'))
-  })
-  test('claude resume-picker [Down] → cursor-down only', () => {
-    expect(keysToBytes(['Down'])).toEqual(Buffer.from('\x1b[B'))
-  })
-  test('literal mode -l sends the rest verbatim (executeControl /compact)', () => {
-    expect(keysToBytes(['-l', '/compact'])).toEqual(Buffer.from('/compact'))
-  })
-  test('Escape (interrupt) → ESC', () => {
-    expect(keysToBytes(['Escape'])).toEqual(Buffer.from('\x1b'))
-  })
-  test('an unknown token falls through to literal text', () => {
-    expect(keysToBytes(['hello'])).toEqual(Buffer.from('hello'))
-  })
-})
-
-// boris's acceptance bar: the translator must be BYTE-IDENTICAL to real `tmux send-keys` for the
-// key-set the adapters actually return — not a "looks right" table. We capture exactly what tmux
-// delivers to a pane (raw mode bypasses the line discipline so no CR↔NL cooking) and compare.
-// Guarded by tmuxAvailable (a clean CI runner has no tmux → these skip, per the live-tmux lesson).
-function tmuxSendKeysBytes(keys: string[], appCursor: boolean, n: number): Buffer {
-  const dir = mkdtempSync(join(tmpdir(), 'pts-keys-'))
-  const sock = join(dir, 's.sock')
-  const out = join(dir, 'out.bin')
-  // The pane program: optionally emit DECCKM (CSI ? 1 h) as its OWN output so tmux tracks
-  // application-cursor mode; then raw mode (capture send-keys bytes verbatim); then read exactly n
-  // bytes and exit (head flushes on exit — a buffered cat would lose the tail on kill).
-  const pre = appCursor ? `printf '\\033[?1h'; ` : ''
-  const paneCmd = `${pre}stty raw -echo; head -c ${n} > '${out}'`
-  try {
-    const create = spawnSync(
-      'tmux',
-      ['-S', sock, 'new-session', '-d', '-s', 'k', '-x', '80', '-y', '24', 'sh', '-c', paneCmd],
-      { stdio: 'ignore' },
-    )
-    if (create.status !== 0) throw new Error('tmux new-session failed')
-    Bun.sleepSync(400) // let the pane reach raw mode + tmux process the DECCKM output
-    spawnSync('tmux', ['-S', sock, 'send-keys', '-t', 'k', ...keys], { stdio: 'ignore' })
-    const deadline = Date.now() + 3000
-    while (Date.now() < deadline) {
-      if (existsSync(out) && statSync(out).size >= n) break
-      Bun.sleepSync(50)
-    }
-    return existsSync(out) ? readFileSync(out) : Buffer.alloc(0)
-  } finally {
-    spawnSync('tmux', ['-S', sock, 'kill-server'], { stdio: 'ignore' })
-    try {
-      rmSync(dir, { recursive: true, force: true })
-    } catch {
-      /* */
-    }
-  }
-}
-
-describe.if(tmuxAvailable)('keysToBytes byte-identity vs real tmux send-keys (live)', () => {
-  test('NORMAL cursor mode: [Down,Enter]', () => {
-    const ours = keysToBytes(['Down', 'Enter'])
-    expect(tmuxSendKeysBytes(['Down', 'Enter'], false, ours.length)).toEqual(ours)
-  })
-  test('DECCKM application-cursor mode: [Down,Enter] → SS3', () => {
-    const ours = keysToBytes(['Down', 'Enter'], { appCursorKeys: true })
-    expect(tmuxSendKeysBytes(['Down', 'Enter'], true, ours.length)).toEqual(ours)
-  })
-  test('literal digit + Enter: [2,Enter]', () => {
-    const ours = keysToBytes(['2', 'Enter'])
-    expect(tmuxSendKeysBytes(['2', 'Enter'], false, ours.length)).toEqual(ours)
-  })
-  test('bare Enter', () => {
-    const ours = keysToBytes(['Enter'])
-    expect(tmuxSendKeysBytes(['Enter'], false, ours.length)).toEqual(ours)
-  })
-})

package/src/supervisor/selfargv.test.ts

@@ -1,22 +0,0 @@
-// Spawn-flip Ф1 serving-wiring — resolveDaemonSelfArgv picks the right re-invocation for the detached
-// supervisor daemon: a real on-disk module (bun/source) runs directly; an EMBEDDED module (a compiled
-// `bun build --compile` standalone, whose self path is NOT on disk) re-invokes the installed binary
-// through its `supervisor` verb. The bug this guards: a bare bunfs-path invocation mis-routes through
-// the CLI (unknown verb → usage), the daemon never comes up, and a hosted launch falls back to tmux.
-import { describe, expect, test } from 'bun:test'
-import { resolveDaemonSelfArgv } from './index.ts'
-
-describe('resolveDaemonSelfArgv', () => {
-  // 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 (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 dump).
-  })
-})

package/src/supervisor/spinner-strip.test.ts

@@ -1,52 +0,0 @@
-// Scrollback spinner strip (serve-side repaint snapshot). claude's TUI redraws its status block without
-// a scroll-region, so stale spinner frames accumulate in the @xterm scrollback ring and pollute a
-// reattaching operator's scroll-up. stripSpinnerScrollback drops those frames from the SCROLLBACK part
-// of the serialized snapshot while keeping the live viewport (incl. the current spinner) verbatim,
-// matched by STRUCTURE (gerund + … + elapsed/token or esc-to-interrupt tail), not a word-list.
-import { describe, expect, test } from 'bun:test'
-import { stripSpinnerScrollback } from './daemon.ts'
-
-describe('stripSpinnerScrollback — drop stale spinner frames from served scrollback', () => {
-  test('strips scrollback spinner-status lines (elapsed + tokens), keeps real history + the live viewport', () => {
-    const lines = [
-      'real history line 1',
-      '\x1b[38;2;215;119;87m✶\x1b[39m Metamorphosing… (4m 24s · ↓ 18.4k tokens)', // scrollback spinner → drop
-      'real history line 2',
-      '· Quantumizing… (6m 57s · ↓ 30.0k tokens)', // scrollback spinner → drop
-      // last 3 = viewport (the LIVE status block, kept verbatim incl. the current spinner)
-      'real history line 3',
-      '────────────',
-      '✽ Brewing… (1m 59s · ↓ 6.5k tokens)',
-    ].join('\r\n')
-    const out = stripSpinnerScrollback(lines, 3).split('\r\n')
-    expect(out).toContain('real history line 1')
-    expect(out).toContain('real history line 2')
-    expect(out).toContain('real history line 3')
-    expect(out).toContain('✽ Brewing… (1m 59s · ↓ 6.5k tokens)') // viewport live spinner KEPT
-    expect(out.some(l => /Metamorphosing/.test(l))).toBe(false)
-    expect(out.some(l => /Quantumizing/.test(l))).toBe(false)
-  })
-
-  test('strips the (esc to interrupt) tail variant in scrollback', () => {
-    const lines = ['history', '· Running… (esc to interrupt · 1.2k tokens)', 'vp1', 'vp2', 'vp3'].join('\r\n')
-    const out = stripSpinnerScrollback(lines, 3)
-    expect(out.includes('Running…')).toBe(false)
-    expect(out.includes('history')).toBe(true)
-  })
-
-  test('does NOT over-strip — real content with … or (…) but no spinner tail is kept', () => {
-    const lines = [
-      'мы обсудили тайминг… он занял время', // … but no elapsed/token tail
-      'итого вышло (5 долларов)', //          (…) but no elapsed/esc tail
-      'vp1', 'vp2', 'vp3',
-    ].join('\r\n')
-    const out = stripSpinnerScrollback(lines, 3).split('\r\n')
-    expect(out).toContain('мы обсудили тайминг… он занял время')
-    expect(out).toContain('итого вышло (5 долларов)')
-  })
-
-  test('the LIVE spinner in the viewport is never stripped (no scrollback → unchanged)', () => {
-    const lines = ['✶ Vibing… (3s · ↓ 1 tokens)', 'vp2', 'vp3'].join('\r\n')
-    expect(stripSpinnerScrollback(lines, 3)).toBe(lines) // segs <= viewportRows → returned verbatim
-  })
-})

package/src/transport/compactDone.test.ts

@@ -1,144 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync, appendFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { compactDoneBaseline, compactTranscriptHasDone, waitForCompactDone, type DeliveryTarget } from './index.ts'
-
-function claudeTarget(): DeliveryTarget {
-  return { runtime: 'claude', personality: 'tester', address: 'claude-tester', socketPath: '/tmp/iapeer-test-noop.sock' }
-}
-
-const CLAUDE_IDLE_PANE = '❯ \n bypass permissions on'
-const CLAUDE_BUSY_PANE = '· Compacting conversation… (esc to interrupt)\n  reloading context'
-
-function withHome(fn: (home: string, env: NodeJS.ProcessEnv) => void): void {
-  const home = mkdtempSync(join(tmpdir(), 'iapeer-compact-gate-home-'))
-  try {
-    fn(home, { ...process.env, HOME: home })
-  } finally {
-    rmSync(home, { recursive: true, force: true })
-  }
-}
-
-function claudeSlug(cwd: string): string {
-  return realpathSync(cwd).replace(/[^a-zA-Z0-9]/g, '-')
-}
-
-describe('compact done transcript gate', () => {
-  test('codex: ignores old markers and detects a new context_compacted event', () => withHome((home, env) => {
-    const cwd = mkdtempSync(join(tmpdir(), 'iapeer-compact-codex-cwd-'))
-    try {
-      const dir = join(home, '.codex', 'sessions', '2026', '06', '13')
-      mkdirSync(dir, { recursive: true })
-      const file = join(dir, 'rollout-test.jsonl')
-      writeFileSync(file,
-        JSON.stringify({ type: 'session_meta', payload: { cwd } }) + '\n' +
-        JSON.stringify({ type: 'event_msg', payload: { type: 'context_compacted' } }) + '\n',
-      )
-      const baseline = compactDoneBaseline('codex', cwd, { env })
-      expect(compactTranscriptHasDone(baseline, { env })).toBe(false)
-      appendFileSync(file, JSON.stringify({ type: 'event_msg', payload: { type: 'context_compacted' } }) + '\n')
-      expect(compactTranscriptHasDone(baseline, { env })).toBe(true)
-    } finally {
-      rmSync(cwd, { recursive: true, force: true })
-    }
-  }))
-
-  test('claude: detects a new compact_boundary and ignores raw text mentions', () => withHome((home, env) => {
-    const cwd = mkdtempSync(join(tmpdir(), 'iapeer-compact-claude-cwd-'))
-    try {
-      const dir = join(home, '.claude', 'projects', claudeSlug(cwd))
-      mkdirSync(dir, { recursive: true })
-      const file = join(dir, 'session.jsonl')
-      writeFileSync(file,
-        JSON.stringify({ type: 'user', message: { role: 'user', content: 'context_compacted is only text' } }) + '\n' +
-        JSON.stringify({ type: 'system', subtype: 'compact_boundary', content: 'Conversation compacted' }) + '\n',
-      )
-      const baseline = compactDoneBaseline('claude', cwd, { env })
-      expect(compactTranscriptHasDone(baseline, { env })).toBe(false)
-      appendFileSync(file, JSON.stringify({ type: 'user', message: { role: 'user', content: 'Conversation compacted text only' } }) + '\n')
-      expect(compactTranscriptHasDone(baseline, { env })).toBe(false)
-      appendFileSync(file, JSON.stringify({ type: 'system', subtype: 'compact_boundary', content: 'Conversation compacted', compactMetadata: { durationMs: 12 } }) + '\n')
-      expect(compactTranscriptHasDone(baseline, { env })).toBe(true)
-    } finally {
-      rmSync(cwd, { recursive: true, force: true })
-    }
-  }))
-})
-
-describe('waitForCompactDone — marker is authoritative, idle is a fast-path', () => {
-  function withClaudeMarker(
-    fn: (args: { cwd: string; env: NodeJS.ProcessEnv; writeMarker: () => void; baseline: ReturnType<typeof compactDoneBaseline> }) => void,
-  ): void {
-    withHome((home, env) => {
-      const cwd = mkdtempSync(join(tmpdir(), 'iapeer-compact-wait-cwd-'))
-      try {
-        const dir = join(home, '.claude', 'projects', claudeSlug(cwd))
-        mkdirSync(dir, { recursive: true })
-        const file = join(dir, 'session.jsonl')
-        writeFileSync(file, JSON.stringify({ type: 'user', message: { role: 'user', content: 'hi' } }) + '\n')
-        const baseline = compactDoneBaseline('claude', cwd, { env })
-        const writeMarker = () =>
-          appendFileSync(file, JSON.stringify({ type: 'system', subtype: 'compact_boundary', compactMetadata: { durationMs: 140708, preTokens: 535706, postTokens: 12524 } }) + '\n')
-        fn({ cwd, env, writeMarker, baseline })
-      } finally {
-        rmSync(cwd, { recursive: true, force: true })
-      }
-    })
-  }
-
-  // THE FIX: a large-context session that auto-continues into a working turn after compact
-  // keeps the composer busy (never idle). The marker proves completion → SUCCESS, not failure.
-  test('marker seen + composer never idle → success on the marker (signal: transcript)', () => withClaudeMarker(({ cwd, env, writeMarker, baseline }) => {
-    writeMarker()
-    const r = waitForCompactDone(claudeTarget(), cwd, baseline, {
-      env,
-      timeoutMs: 5000,
-      pollMs: 5,
-      graceMs: 20,
-      seam: { sessionAlive: () => true, capturePane: () => CLAUDE_BUSY_PANE },
-    })
-    expect(r.ok).toBe(true)
-    if (r.ok) expect(r.value.signal).toBe('transcript')
-  }))
-
-  // Clean common case unchanged: marker + idle composer → the historical 'transcript+ready'.
-  test('marker seen + composer idle → fast-path success (signal: transcript+ready)', () => withClaudeMarker(({ cwd, env, writeMarker, baseline }) => {
-    writeMarker()
-    const r = waitForCompactDone(claudeTarget(), cwd, baseline, {
-      env,
-      timeoutMs: 5000,
-      pollMs: 5,
-      graceMs: 5000,
-      seam: { sessionAlive: () => true, capturePane: () => CLAUDE_IDLE_PANE },
-    })
-    expect(r.ok).toBe(true)
-    if (r.ok) expect(r.value.signal).toBe('transcript+ready')
-  }))
-
-  // BOUNDARY preserved: no structured marker ever → honest failure (hung / never completed).
-  test('no marker → honest failure', () => withClaudeMarker(({ cwd, env, baseline }) => {
-    const r = waitForCompactDone(claudeTarget(), cwd, baseline, {
-      env,
-      timeoutMs: 40,
-      pollMs: 5,
-      graceMs: 20,
-      seam: { sessionAlive: () => true, capturePane: () => CLAUDE_BUSY_PANE },
-    })
-    expect(r.ok).toBe(false)
-    if (!r.ok) expect(r.error.message).toContain('no transcript compact marker')
-  }))
-
-  // Session death during the wait still fails (liveness boundary).
-  test('session vanished → failure', () => withClaudeMarker(({ cwd, env, baseline }) => {
-    const r = waitForCompactDone(claudeTarget(), cwd, baseline, {
-      env,
-      timeoutMs: 5000,
-      pollMs: 5,
-      graceMs: 20,
-      seam: { sessionAlive: () => false, capturePane: () => CLAUDE_BUSY_PANE },
-    })
-    expect(r.ok).toBe(false)
-    if (!r.ok) expect(r.error.message).toContain('session vanished')
-  }))
-})

package/src/transport/composerQueue.test.ts

@@ -1,204 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { ok } from '../core/errors.ts'
-import { getAdapter } from '../launch/index.ts'
-import type { PeerRecord } from '../registry/index.ts'
-import type { ResolvedCaller } from '../identity/index.ts'
-import {
-  composerCaptureHasHumanInput,
-  createComposerDeliveryQueue,
-  type ComposerQueueTryEnqueueArgs,
-  type DeliveryTarget,
-} from './index.ts'
-
-const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
-
-describe('composerCaptureHasHumanInput (SGR color gate)', () => {
-  test('codex: default-fg text after › is human input; faint/grey ghost text is not', () => {
-    const markers = getAdapter('codex').deliveryMarkers
-    expect(composerCaptureHasHumanInput('\x1b[32m›\x1b[0m hello', markers)).toBe(true)
-    expect(composerCaptureHasHumanInput('\x1b[32m›\x1b[0m \x1b[2mghost suggestion\x1b[0m', markers)).toBe(false)
-    expect(composerCaptureHasHumanInput('\x1b[32m›\x1b[0m \x1b[38;5;246mplaceholder\x1b[0m', markers)).toBe(false)
-    // A suggestion accepted into the composer is no longer grey/faint; it must be held.
-    expect(composerCaptureHasHumanInput('\x1b[32m›\x1b[0m accepted suggestion', markers)).toBe(true)
-  })
-
-  test('claude: same color rule is runtime-owned behind the ❯ prompt glyph', () => {
-    const markers = getAdapter('claude').deliveryMarkers
-    expect(composerCaptureHasHumanInput('\x1b[35m❯\x1b[0m human', markers)).toBe(true)
-    expect(composerCaptureHasHumanInput('\x1b[35m❯\x1b[0m \x1b[2mghost\x1b[0m', markers)).toBe(false)
-    expect(composerCaptureHasHumanInput('\x1b[35m❯\x1b[0m \x1b[38;5;246mplaceholder\x1b[0m', markers)).toBe(false)
-  })
-})
-
-const callerRecord = {
-  personality: 'sender',
-  runtime: 'codex',
-  runtimes: ['codex'],
-  description: '',
-  intelligence: 'artificial',
-  cwd: '/tmp/sender',
-} as unknown as PeerRecord
-const caller: ResolvedCaller = {
-  personality: 'sender',
-  runtime: 'codex',
-  address: 'codex-sender',
-  description: '',
-  intelligence: 'artificial',
-  cwd: '/tmp/sender',
-  record: callerRecord,
-}
-const peer = {
-  personality: 'target',
-  runtime: 'codex',
-  runtimes: ['codex'],
-  description: '',
-  intelligence: 'artificial',
-  cwd: '/tmp/target',
-} as unknown as PeerRecord
-const target: DeliveryTarget = {
-  personality: 'target',
-  runtime: 'codex',
-  address: 'codex-target',
-  socketPath: '/tmp/no-such-sock',
-}
-function args(envelope = '<iap>hello</iap>'): ComposerQueueTryEnqueueArgs {
-  return { caller, peer, target, envelope, topic: 'q-test' }
-}
-
-describe('createComposerDeliveryQueue', () => {
-  test('queued ack is immediate; drain waits until composer clears, then delivers silently', async () => {
-    let held = true
-    const delivered: string[] = []
-    const failed: string[] = []
-    const q = createComposerDeliveryQueue({
-      pollMs: 5,
-      forceTimeoutMs: 1000,
-      shouldQueue: () => true,
-      hasHumanInput: () => held,
-      sessionToken: () => 'session-1:pane-1',
-      sessionAlive: () => true,
-      deliver: (_target, envelope) => {
-        delivered.push(envelope)
-        return ok(undefined)
-      },
-      notifyFailed: (_job, reason) => { failed.push(reason) },
-    })
-
-    const accepted = await q.tryEnqueue(args('first'))
-    expect(accepted?.ok).toBe(true)
-    if (!accepted?.ok) return
-    expect(accepted.value).toMatchObject({ queued: true, queuedBy: 'composer', queueDepth: 1 })
-    await sleep(20)
-    expect(delivered).toEqual([])
-    held = false
-    await sleep(30)
-    expect(delivered).toEqual(['first'])
-    expect(failed).toEqual([])
-  })
-
-  test('120s ceiling (env-tunable in tests) force-delivers instead of waiting forever', async () => {
-    const delivered: string[] = []
-    const failed: string[] = []
-    const q = createComposerDeliveryQueue({
-      pollMs: 5,
-      forceTimeoutMs: 20,
-      shouldQueue: () => true,
-      hasHumanInput: () => true,
-      sessionToken: () => 'session-1:pane-1',
-      sessionAlive: () => true,
-      deliver: (_target, envelope) => {
-        delivered.push(envelope)
-        return ok(undefined)
-      },
-      notifyFailed: (_job, reason) => { failed.push(reason) },
-    })
-
-    await q.tryEnqueue(args('force-me'))
-    await sleep(70)
-    expect(delivered).toEqual(['force-me'])
-    expect(failed).toEqual([])
-  })
-
-  test('target death/session replacement fails the queued sender instead of delivering to a corpse/new session', async () => {
-    let alive = true
-    const delivered: string[] = []
-    const failed: string[] = []
-    const q = createComposerDeliveryQueue({
-      pollMs: 5,
-      forceTimeoutMs: 1000,
-      shouldQueue: () => true,
-      hasHumanInput: () => true,
-      sessionToken: () => 'session-1:pane-1',
-      sessionAlive: () => alive,
-      deliver: (_target, envelope) => {
-        delivered.push(envelope)
-        return ok(undefined)
-      },
-      notifyFailed: (_job, reason) => { failed.push(reason) },
-    })
-
-    await q.tryEnqueue(args('must-fail'))
-    alive = false
-    await sleep(30)
-    expect(delivered).toEqual([])
-    expect(failed.join('\n')).toMatch(/vanished|replaced/)
-  })
-
-  test('async-correctness: concurrent enqueue with ASYNC predicates → each delivered exactly once, no dup/loss (Ф0b-3 3c-2)', async () => {
-    // The host-aware refactor makes shouldQueue/hasHumanInput/deliver awaitable. Inject ASYNC seams
-    // (a real yield window) and fire concurrent enqueues — the FIFO + per-identity drain guard must
-    // still deliver each envelope EXACTLY once (no race-doubled, no race-lost).
-    let held = true
-    const delivered: string[] = []
-    const q = createComposerDeliveryQueue({
-      pollMs: 5,
-      forceTimeoutMs: 2000,
-      shouldQueue: async () => { await sleep(4); return true },
-      hasHumanInput: async () => { await sleep(2); return held },
-      sessionToken: () => 'session-1:pane-1',
-      sessionAlive: () => true,
-      deliver: async (_target, envelope) => { await sleep(1); delivered.push(envelope); return ok(undefined) },
-      notifyFailed: () => { /* */ },
-    })
-
-    const acks = await Promise.all([
-      q.tryEnqueue(args('msg-A')),
-      q.tryEnqueue(args('msg-B')),
-      q.tryEnqueue(args('msg-C')),
-    ])
-    expect(acks.every(a => a?.ok)).toBe(true)
-    await sleep(40)
-    expect(delivered).toEqual([]) // all three held while busy
-    held = false
-    await sleep(80)
-    expect(delivered.slice().sort()).toEqual(['msg-A', 'msg-B', 'msg-C']) // each ONCE — no dup, no loss
-  })
-
-  test('daemon close/restart failAll re-fails every queued-but-undelivered envelope', async () => {
-    const delivered: string[] = []
-    const failed: string[] = []
-    const q = createComposerDeliveryQueue({
-      pollMs: 50,
-      forceTimeoutMs: 1000,
-      shouldQueue: () => true,
-      hasHumanInput: () => true,
-      sessionToken: () => 'session-1:pane-1',
-      sessionAlive: () => true,
-      deliver: (_target, envelope) => {
-        delivered.push(envelope)
-        return ok(undefined)
-      },
-      notifyFailed: (_job, reason) => { failed.push(reason) },
-    })
-
-    await q.tryEnqueue(args('queued-a'))
-    await q.tryEnqueue(args('queued-b'))
-    await q.failAll?.('daemon shutting down/restarting before queued delivery completed')
-    await sleep(10)
-    expect(delivered).toEqual([])
-    expect(failed).toEqual([
-      'daemon shutting down/restarting before queued delivery completed',
-      'daemon shutting down/restarting before queued delivery completed',
-    ])
-  })
-})