@agfpd/iapeer 0.2.76 → 0.2.78

package/src/runtime/update.test.ts

@@ -1,192 +0,0 @@
-// update-runtime (§(г)) — version-gate / forced re-install / idempotent re-provision /
-// peer restart. Sandboxed (IAPEER_ROOT temp dirs, IAPEER_TEST_SANDBOX), injected
-// npx + npm-version + restart.
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { updateAllRuntimes, updateRuntime, type RestartedPeer } from './update.ts'
-import { readRuntimeManifest, writeRuntimeManifest, type RuntimeManifest } from './index.ts'
-import { upsertPeer } from '../registry/index.ts'
-
-const roots: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-rtup-'))
-  roots.push(d)
-  return d
-}
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function envFor(root: string, path?: string): NodeJS.ProcessEnv {
-  return {
-    IAPEER_ROOT: join(root, 'iapeer'),
-    IAPEER_LAUNCHAGENTS_DIR: join(root, 'LA'),
-    IAPEER_TEST_SANDBOX: '1',
-    HOME: root,
-    ...(path ? { PATH: path } : {}),
-  } as NodeJS.ProcessEnv
-}
-
-function stubBins(): { dir: string; hook: string } {
-  const dir = mkTmp()
-  writeFileSync(join(dir, 'notifier-runtime'), '#!/bin/sh\nexec sleep 1\n', { mode: 0o755 })
-  const hook = join(dir, 'sc.sh')
-  writeFileSync(hook, '#!/bin/sh\nexit 0\n', { mode: 0o755 })
-  return { dir, hook }
-}
-
-const restartOk =
-  (log: string[]) =>
-  (personality: string): RestartedPeer => {
-    log.push(personality)
-    return { personality, state: 'restarted' }
-  }
-
-describe('updateRuntime (§(г): gate → re-install → re-provision → restart)', () => {
-  test('full update: re-npx forced, declared set re-provisioned, peers restarted', async () => {
-    const root = mkTmp()
-    const { dir, hook } = stubBins()
-    const env = envFor(root, dir)
-    writeRuntimeManifest(
-      { runtime: 'notifier', version: '0.1.0', selfConfig: hook, peers: [{ personality: 'timer', intelligence: 'absent' }] },
-      { env },
-    )
-    // the live-host layout: the declared peer already sits in its DEFAULT location
-    // (re-provision must be a no-clobber pass over it, not an identity conflict)
-    await upsertPeer(
-      { personality: 'timer', runtime: 'notifier', cwd: join(root, 'iapeer', 'peers', 'timer'), intelligence: 'absent' },
-      { env },
-    )
-    let npxRan = false
-    const restarts: string[] = []
-    const r = await updateRuntime({
-      runtime: 'notifier',
-      env,
-      runNpx: (_pkg, e) => {
-        npxRan = true
-        // the package self-deploys the NEW manifest with the new version stamp
-        const m: RuntimeManifest = { runtime: 'notifier', version: '0.2.0', selfConfig: hook, peers: [{ personality: 'timer', intelligence: 'absent' }] }
-        writeRuntimeManifest(m, { env: e })
-        return { ok: true }
-      },
-      npmVersion: () => '0.2.0',
-      restartPeer: restartOk(restarts),
-    })
-    expect(r.state).toBe('updated')
-    expect(npxRan).toBe(true) // FORCED re-npx despite the present manifest
-    expect(r.from).toBe('0.1.0')
-    expect(r.to).toBe('0.2.0')
-    expect(r.peers.map(p => p.personality)).toEqual(['timer']) // re-provisioned
-    expect(restarts).toEqual(['timer']) // restarted via the injected stop/start
-    expect(readRuntimeManifest('notifier', { env })?.version).toBe('0.2.0')
-  })
-
-  test('version-gate: manifest stamp equals npm latest → already-latest, NOTHING runs', async () => {
-    const env = envFor(mkTmp())
-    writeRuntimeManifest({ runtime: 'notifier', version: '0.2.0' }, { env })
-    let npxRan = false
-    const r = await updateRuntime({ runtime: 'notifier', env, runNpx: () => ((npxRan = true), { ok: true }), npmVersion: () => '0.2.0' })
-    expect(r.state).toBe('already-latest')
-    expect(npxRan).toBe(false)
-  })
-
-  test('--force overrides the gate', async () => {
-    const root = mkTmp()
-    const { dir, hook } = stubBins()
-    const env = envFor(root, dir)
-    writeRuntimeManifest({ runtime: 'notifier', version: '0.2.0', selfConfig: hook }, { env })
-    let npxRan = false
-    const r = await updateRuntime({
-      runtime: 'notifier',
-      env,
-      force: true,
-      runNpx: () => ((npxRan = true), { ok: true }),
-      npmVersion: () => '0.2.0',
-      restartPeer: restartOk([]),
-    })
-    expect(r.state).toBe('updated')
-    expect(npxRan).toBe(true)
-  })
-
-  test('no version stamp → gate skipped, idempotent re-install with an honest detail', async () => {
-    const root = mkTmp()
-    const { dir, hook } = stubBins()
-    const env = envFor(root, dir)
-    writeRuntimeManifest({ runtime: 'notifier', selfConfig: hook }, { env }) // owners have not stamped yet
-    const r = await updateRuntime({
-      runtime: 'notifier',
-      env,
-      runNpx: () => ({ ok: true }),
-      npmVersion: () => '0.2.0',
-      restartPeer: restartOk([]),
-    })
-    expect(r.state).toBe('updated')
-    expect(r.detail).toContain('no version stamp')
-  })
-
-  test('not installed → not-installed with the install-runtime recipe; npm unreachable → loud', async () => {
-    const env = envFor(mkTmp())
-    const r = await updateRuntime({ runtime: 'notifier', env, npmVersion: () => '0.2.0' })
-    expect(r.state).toBe('not-installed')
-    expect(r.detail).toContain('install-runtime notifier')
-    writeRuntimeManifest({ runtime: 'notifier', version: '0.1.0' }, { env })
-    const r2 = await updateRuntime({ runtime: 'notifier', env, npmVersion: () => null })
-    expect(r2.state).toBe('npm-unreachable')
-  })
-
-  test('failed re-npx → install-failed, no deploy, no restarts', async () => {
-    const env = envFor(mkTmp())
-    writeRuntimeManifest({ runtime: 'notifier', version: '0.1.0' }, { env })
-    const restarts: string[] = []
-    const r = await updateRuntime({
-      runtime: 'notifier',
-      env,
-      runNpx: () => ({ ok: false, detail: 'network down' }),
-      npmVersion: () => '0.2.0',
-      restartPeer: restartOk(restarts),
-    })
-    expect(r.state).toBe('install-failed')
-    expect(restarts).toEqual([])
-  })
-
-  test('mode-b runtime (telegram, no declared peers): empty re-provision, registered router restarted', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    writeRuntimeManifest({ runtime: 'telegram', version: '0.10.0' }, { env })
-    await upsertPeer({ personality: 'arthur', runtime: 'telegram', cwd: '/tmp/arthur', intelligence: 'natural' }, { env })
-    const restarts: string[] = []
-    const r = await updateRuntime({
-      runtime: 'telegram',
-      env,
-      runNpx: (_pkg, e) => {
-        writeRuntimeManifest({ runtime: 'telegram', version: '0.10.3' }, { env: e })
-        return { ok: true }
-      },
-      npmVersion: () => '0.10.3',
-      restartPeer: restartOk(restarts),
-    })
-    expect(r.state).toBe('updated')
-    expect(r.peers).toEqual([]) // operator-add runtime: nothing declared to re-provision
-    expect(restarts).toEqual(['arthur']) // the router still restarts onto the new code
-  })
-})
-
-describe('updateAllRuntimes (--all)', () => {
-  test('updates installed runtimes, reports the rest not-installed (never an error)', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    writeRuntimeManifest({ runtime: 'telegram', version: '1.0.0' }, { env })
-    const results = await updateAllRuntimes({
-      env,
-      runNpx: () => ({ ok: true }),
-      npmVersion: () => '1.0.0',
-      restartPeer: restartOk([]),
-    })
-    const byRt = Object.fromEntries(results.map(r => [r.runtime, r.state]))
-    expect(byRt.telegram).toBe('already-latest')
-    expect(byRt.notifier).toBe('not-installed')
-  })
-})

package/src/shadow/enumerate-skip.test.ts

@@ -1,67 +0,0 @@
-// Spawn-flip cutover Block 2, Ф0b-3 slice 3b — the fidelity observer SKIPS supervisor-hosted peers.
-//
-// The observer compares the pty-model vs LIVE TMUX. pty-hosting is now the DEFAULT, so a normal
-// (unmarked) peer has no tmux to compare against — and during a flip a lingering tmux socket for it
-// would surface FALSE divergences. This proves the skip fires IN enumerate even in that race (a live
-// tmux session + a pane-log present): the default peer is NOT enrolled, while a `.no-pty-host` opt-out
-// (tmux) sibling IS. Real-tmux, guarded (a clean CI runner has no tmux; the release machine has it —
-// same pattern as routesend-wake).
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { spawnSync } from 'node:child_process'
-import { closeSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { buildSocketPath } from '../core/socket.ts'
-import { enumerate } from './index.ts'
-
-const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0
-
-let sockDir: string
-let logDir: string
-const KEEP = 'keepobs' // .no-pty-host opt-out (tmux) → observed
-const SKIP = 'skipobs' // default (no marker) → pty-hosted → skipped
-const addrOf = (p: string) => `codex-${p}`
-const sockOf = (p: string) => buildSocketPath('codex', p, sockDir)
-
-function startTmux(personality: string): void {
-  const r = spawnSync(
-    'tmux',
-    ['-S', sockOf(personality), 'new-session', '-d', '-x', '80', '-y', '24', '-s', addrOf(personality), 'cat'],
-    { encoding: 'utf8' },
-  )
-  if (r.status !== 0) throw new Error(`tmux new-session failed: ${r.stderr}`)
-}
-function killTmux(personality: string): void {
-  spawnSync('tmux', ['-S', sockOf(personality), 'kill-server'], { stdio: 'ignore' })
-}
-
-beforeAll(() => {
-  sockDir = mkdtempSync(join(tmpdir(), 'iapeer-obs-sock-'))
-  logDir = mkdtempSync(join(tmpdir(), 'iapeer-obs-log-'))
-  if (!tmuxAvailable) return
-  // Both peers: a live tmux session + a pane-log (so enrolment is otherwise satisfied).
-  for (const p of [KEEP, SKIP]) {
-    startTmux(p)
-    writeFileSync(join(logDir, `${addrOf(p)}.log`), '')
-  }
-  // KEEP carries the `.no-pty-host` opt-OUT → it is on tmux, so the observer MUST compare it. SKIP is a
-  // DEFAULT (unmarked) peer → pty-hosted → skipped even WITH a lingering live tmux session (the
-  // flip-transition race the skip guards against).
-  writeFileSync(join(logDir, `${addrOf(KEEP)}.no-pty-host`), '')
-})
-
-afterAll(() => {
-  if (tmuxAvailable) for (const p of [KEEP, SKIP]) killTmux(p)
-  rmSync(sockDir, { recursive: true, force: true })
-  rmSync(logDir, { recursive: true, force: true })
-})
-
-describe.if(tmuxAvailable)('observer enumerate skips pty-default peers, compares .no-pty-host (tmux) peers', () => {
-  test('a default (unmarked, pty-hosted) peer is NOT enrolled despite a live tmux session; a .no-pty-host opt-out one IS', () => {
-    const models = new Map<string, any>()
-    enumerate(models, { sockDir, logDir, eventLogDir: logDir })
-    expect(models.has(addrOf(KEEP))).toBe(true) // .no-pty-host opt-out (tmux) → observed (live tmux + log)
-    expect(models.has(addrOf(SKIP))).toBe(false) // default pty-hosted → skipped despite lingering live tmux
-    for (const o of models.values()) { try { if (o.fd != null) closeSync(o.fd) } catch { /* */ } }
-  })
-})

package/src/shadow/gate.test.ts

@@ -1,286 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import {
-  GateTracker,
-  classifyDirection,
-  classifySampleState,
-  evaluateReadyGateFlipEligibility,
-  type GateSummary,
-  type PeerSample,
-  type VerdictGateStat,
-} from './gate.ts'
-
-// SYNTHETIC ACCEPTANCE (boris's Block-1 gate): prove the instrument classifies known-behind vs
-// known-ahead and records coverage CORRECTLY — the live proof that it measures right before we
-// trust any pty verdict for a flip. Pure: no tmux, no @xterm, booleans in, gate stats out.
-
-const mkSample = (peer: string, runtime: string, over: Partial<PeerSample> = {}): PeerSample => ({
-  peer,
-  runtime,
-  occupancy: { pty: false, tmux: false },
-  readyGate: { pty: false, tmux: false },
-  liveness: { pty: true, tmux: true },
-  bytesFed: 0,
-  hasHistory: false,
-  ...over,
-})
-
-describe('classifyDirection (tmux authoritative; true = active/ready/alive pole)', () => {
-  test('equal → agree', () => {
-    expect(classifyDirection(true, true)).toBe('agree')
-    expect(classifyDirection(false, false)).toBe('agree')
-  })
-  test('pty under-reports (false vs true) → pty-behind (the stale class)', () => {
-    expect(classifyDirection(false, true)).toBe('pty-behind')
-  })
-  test('pty over-reports (true vs false) → pty-ahead', () => {
-    expect(classifyDirection(true, false)).toBe('pty-ahead')
-  })
-})
-
-describe('classifySampleState (coverage regimes — idle must be distinguishable, false-green lesson)', () => {
-  test('tmux occupancy → composer-busy (regardless of bytes)', () => {
-    expect(classifySampleState(true, 0)).toBe('composer-busy')
-    expect(classifySampleState(true, 999)).toBe('composer-busy')
-  })
-  test('no occupancy + output churn → model-advancing (non-trivial regime)', () => {
-    expect(classifySampleState(false, 4096)).toBe('model-advancing')
-  })
-  test('no occupancy + no churn → idle', () => {
-    expect(classifySampleState(false, 0)).toBe('idle')
-  })
-})
-
-describe('GateTracker — direction is scored hard vs benign per the adjudicated criterion', () => {
-  test('pty-BEHIND is ALWAYS hard (zero tolerance) and closes the verdict gate', () => {
-    const g = new GateTracker()
-    g.sample(0, mkSample('p', 'claude', { occupancy: { pty: false, tmux: true } }))
-    const s = g.summary()
-    expect(s.verdicts.occupancy.behind).toBe(1)
-    expect(s.verdicts.occupancy.gateClean).toBe(false)
-    expect(s.hardViolations.some(v => v.kind === 'behind' && v.verdict === 'occupancy')).toBe(true)
-  })
-
-  test('boot-window pty-AHEAD that self-heals within budget → BENIGN (latency recorded)', () => {
-    const g = new GateTracker({ settleTicks: 3, convergeBudgetTicks: 3 })
-    // tick0: readyGate ahead (pty ready, tmux not) — peer just born → boot window
-    g.sample(0, mkSample('p', 'claude', { readyGate: { pty: true, tmux: false } }))
-    // tick1: readyGate agrees (both ready) → transient closes, latency 1, boot+within budget → benign
-    g.sample(1, mkSample('p', 'claude', { readyGate: { pty: true, tmux: true } }))
-    const rg = g.summary().verdicts.readyGate
-    expect(rg.aheadBenign).toBe(1)
-    expect(rg.aheadHard).toBe(0)
-    expect(rg.gateClean).toBe(true)
-    expect(rg.selfHeal.count).toBe(1)
-    expect(rg.selfHeal.max).toBe(1)
-  })
-
-  test('READY-GATE non-converging pty-AHEAD is HARD, never benign (refinement #3: false-ready = msg-loss)', () => {
-    const g = new GateTracker({ settleTicks: 3, convergeBudgetTicks: 3 })
-    // hold readyGate ahead (pty ready, tmux NEVER ready → stays in boot window, never converges)
-    for (let t = 0; t <= 5; t++) g.sample(t, mkSample('p', 'codex', { readyGate: { pty: true, tmux: false } }))
-    const rg = g.summary().verdicts.readyGate
-    expect(rg.aheadHard).toBeGreaterThanOrEqual(1)
-    expect(rg.aheadBenign).toBe(0)
-    expect(rg.gateClean).toBe(false)
-    expect(g.summary().hardViolations.some(v => v.kind === 'ahead-nonconverged' && v.verdict === 'readyGate')).toBe(true)
-  })
-
-  test('STEADY-STATE pty-AHEAD is HARD immediately (cannot be a boot self-heal)', () => {
-    const g = new GateTracker({ settleTicks: 2, convergeBudgetTicks: 3 })
-    // boot the peer: readyGate true for settleTicks
-    g.sample(0, mkSample('p', 'claude', { readyGate: { pty: true, tmux: true } }))
-    g.sample(1, mkSample('p', 'claude', { readyGate: { pty: true, tmux: true } })) // bootDone now
-    // steady-state occupancy ahead → hard 'ahead-steady'
-    g.sample(2, mkSample('p', 'claude', { readyGate: { pty: true, tmux: true }, occupancy: { pty: true, tmux: false } }))
-    const occ = g.summary().verdicts.occupancy
-    expect(occ.aheadHard).toBeGreaterThanOrEqual(1)
-    expect(g.summary().hardViolations.some(v => v.kind === 'ahead-steady' && v.verdict === 'occupancy')).toBe(true)
-  })
-
-  test('full agreement → clean gate, zero hard violations', () => {
-    const g = new GateTracker()
-    for (let t = 0; t < 5; t++) g.sample(t, mkSample('p', 'claude', { readyGate: { pty: true, tmux: true } }))
-    const s = g.summary()
-    expect(s.hardViolations).toHaveLength(0)
-    expect(s.verdicts.readyGate.gateClean).toBe(true)
-    expect(s.verdicts.occupancy.gateClean).toBe(true)
-    expect(s.verdicts.liveness.gateClean).toBe(true)
-  })
-})
-
-describe('GateTracker — coverage matrix (clean counts only over traversed cells)', () => {
-  test('births split fresh vs wake-resume by history-at-first-sight', () => {
-    const g = new GateTracker()
-    g.tickStart(1)
-    g.sample(0, mkSample('fresh-peer', 'claude', { hasHistory: false }))
-    g.tickStart(2)
-    g.sample(1, mkSample('woke-peer', 'codex', { hasHistory: true })) // history at first sight = wake-resume
-    const cov = g.summary().coverage
-    expect(cov.births['claude/fresh']).toBe(1)
-    expect(cov.births['codex/wake-resume']).toBe(1)
-  })
-
-  test('a peer that died and reappeared is a restart', () => {
-    const g = new GateTracker()
-    g.sample(0, mkSample('p', 'claude'))
-    g.peerGone('p')
-    g.sample(5, mkSample('p', 'claude'))
-    expect(g.summary().coverage.restarts['claude']).toBe(1)
-  })
-
-  test('state cells, fleet width, and history samples are recorded', () => {
-    const g = new GateTracker()
-    g.tickStart(3) // fleet width 3 this tick
-    g.sample(0, mkSample('p', 'claude', { occupancy: { pty: true, tmux: true } })) // composer-busy
-    g.sample(1, mkSample('p', 'claude', { bytesFed: 4096 })) // model-advancing
-    g.sample(2, mkSample('p', 'claude', { bytesFed: 0 })) // idle
-    g.sample(3, mkSample('h', 'codex', { hasHistory: true }))
-    const cov = g.summary().coverage
-    expect(cov.fleetWidthMax).toBe(3)
-    expect(cov.byRuntimeState['claude/composer-busy']).toBe(1)
-    expect(cov.byRuntimeState['claude/model-advancing']).toBe(1)
-    expect(cov.byRuntimeState['claude/idle']).toBe(1)
-    expect(cov.historySamples['codex']).toBe(1)
-    expect(cov.runtimes).toEqual(['claude', 'codex'])
-  })
-})
-
-describe('GateTracker — robust center cell (gone→back + history + first-ready parity; cadence-proof)', () => {
-  // Drive a peer through a gone→back cycle: birth (not-ready), then die. The caller's next sample
-  // is the re-enroll (a resume/restart), where the center is evaluated at the first ready sample.
-  const goneBack = (g: GateTracker, peer: string, rt: string): void => {
-    g.sample(0, mkSample(peer, rt, { hasHistory: true, readyGate: { pty: false, tmux: false } }))
-    g.peerGone(peer)
-  }
-
-  test('warm-continuous peer (never gone→back) → NOT counted, even ready-with-history (warm-exclusion)', () => {
-    const g = new GateTracker()
-    g.sample(0, mkSample('w', 'codex', { hasHistory: true, readyGate: { pty: false, tmux: false } }))
-    g.sample(1, mkSample('w', 'codex', { hasHistory: true, readyGate: { pty: true, tmux: true } }))
-    expect(g.summary().coverage.readyResumeCaught['codex']).toBeUndefined()
-  })
-
-  test('gone→back + history + first-ready parity → counted (robust, even first-sight-already-ready)', () => {
-    const g = new GateTracker()
-    goneBack(g, 'c', 'codex')
-    g.sample(1, mkSample('c', 'codex', { hasHistory: true, readyGate: { pty: true, tmux: true } })) // re-enroll already-ready (fast resume)
-    const cov = g.summary().coverage
-    expect(cov.readyResumeCaught['codex']).toBe(1)
-    expect(cov.readyResumeCaughtViaTransition['codex']).toBeUndefined() // window not observed (fast) — still counted
-  })
-
-  test('gone→back WITHOUT history → NOT counted (a fresh restart, not a resume-with-history)', () => {
-    const g = new GateTracker()
-    g.sample(0, mkSample('c', 'codex', { hasHistory: false, readyGate: { pty: false, tmux: false } }))
-    g.peerGone('c')
-    g.sample(1, mkSample('c', 'codex', { hasHistory: false, readyGate: { pty: true, tmux: true } }))
-    expect(g.summary().coverage.readyResumeCaught['codex']).toBeUndefined()
-  })
-
-  test('gone→back + history + DIVERGENCE at first ready (model missed) → NOT counted + dirty (behind)', () => {
-    const g = new GateTracker()
-    goneBack(g, 'c', 'codex')
-    g.sample(1, mkSample('c', 'codex', { hasHistory: true, readyGate: { pty: false, tmux: true } })) // tmux ready, model NOT
-    const s = g.summary()
-    expect(s.coverage.readyResumeCaught['codex']).toBeUndefined()
-    expect(s.verdicts.readyGate.behind).toBeGreaterThanOrEqual(1) // the splash-blind bug → dirty → ineligible
-  })
-
-  test('counted exactly ONCE per life (dedup: one resume = one center++)', () => {
-    const g = new GateTracker()
-    goneBack(g, 'c', 'codex')
-    for (let t = 1; t <= 4; t++) g.sample(t, mkSample('c', 'codex', { hasHistory: true, readyGate: { pty: true, tmux: true } }))
-    expect(g.summary().coverage.readyResumeCaught['codex']).toBe(1)
-  })
-
-  test('observed not-ready→ready window → counted AND flagged caughtViaTransition (diagnostic only)', () => {
-    const g = new GateTracker()
-    goneBack(g, 'c', 'codex')
-    g.sample(1, mkSample('c', 'codex', { hasHistory: true, readyGate: { pty: false, tmux: false } })) // re-enroll not-ready
-    g.sample(2, mkSample('c', 'codex', { hasHistory: true, readyGate: { pty: true, tmux: true } })) // becomes ready
-    const cov = g.summary().coverage
-    expect(cov.readyResumeCaught['codex']).toBe(1)
-    expect(cov.readyResumeCaughtViaTransition['codex']).toBe(1) // window was observed
-  })
-})
-
-describe('evaluateReadyGateFlipEligibility (boris guardrail: the eligibility logic itself under test)', () => {
-  const stat = (over: Partial<VerdictGateStat> = {}): VerdictGateStat => ({
-    samples: 10,
-    agree: 10,
-    behind: 0,
-    aheadBenign: 0,
-    aheadHard: 0,
-    selfHeal: { count: 0, max: 0, mean: 0 },
-    gateClean: true,
-    ...over,
-  })
-  const mkSummary = (over: {
-    rgBehind?: number
-    rgAheadHard?: number
-    center?: Record<string, number>
-    births?: Record<string, number>
-    restarts?: Record<string, number>
-  } = {}): GateSummary => ({
-    verdicts: {
-      occupancy: stat(),
-      readyGate: stat({ behind: over.rgBehind ?? 0, aheadHard: over.rgAheadHard ?? 0 }),
-      liveness: stat(),
-    },
-    hardViolations: [],
-    coverage: {
-      fleetWidthMax: 2,
-      runtimes: ['claude', 'codex'],
-      byRuntimeState: {},
-      births: over.births ?? {},
-      restarts: over.restarts ?? {},
-      historySamples: {},
-      readyResumeCaught: over.center ?? {},
-      readyResumeCaughtViaTransition: {},
-    },
-  })
-  const COMPLETE = {
-    center: { codex: 1 },
-    births: { 'claude/fresh': 1, 'codex/wake-resume': 1 },
-    restarts: { codex: 1 },
-  }
-
-  test('incomplete (empty) → NOT eligible, reasons name every missing cell (actionable)', () => {
-    const e = evaluateReadyGateFlipEligibility(mkSummary())
-    expect(e.eligible).toBe(false)
-    expect(e.reasons.some(r => /center codex×wake-resume×history/.test(r))).toBe(true)
-    expect(e.reasons.some(r => /no codex birth/.test(r))).toBe(true)
-    expect(e.reasons.some(r => /no claude birth/.test(r))).toBe(true)
-    expect(e.reasons.some(r => /no restart/.test(r))).toBe(true)
-  })
-
-  test('complete + clean → eligible', () => {
-    const e = evaluateReadyGateFlipEligibility(mkSummary(COMPLETE))
-    expect(e.eligible).toBe(true)
-    expect(e.reasons).toHaveLength(0)
-  })
-
-  test('complete BUT dirty (readyGate behind) → NOT eligible, reason names the dirt', () => {
-    const e = evaluateReadyGateFlipEligibility(mkSummary({ ...COMPLETE, rgBehind: 2 }))
-    expect(e.eligible).toBe(false)
-    expect(e.reasons.some(r => /readyGate dirty: behind=2/.test(r))).toBe(true)
-  })
-
-  test('complete except the CENTER cell empty → NOT eligible, center reason only', () => {
-    const e = evaluateReadyGateFlipEligibility(mkSummary({ ...COMPLETE, center: {} }))
-    expect(e.eligible).toBe(false)
-    expect(e.reasons).toHaveLength(1)
-    expect(e.reasons[0]).toMatch(/center codex×wake-resume×history: 0/)
-  })
-
-  test('complete except no restart → NOT eligible, restart reason only', () => {
-    const e = evaluateReadyGateFlipEligibility(mkSummary({ ...COMPLETE, restarts: {} }))
-    expect(e.eligible).toBe(false)
-    expect(e.reasons).toEqual(['no restart observed'])
-  })
-
-  test('composer-busy is ORTHOGONAL — its absence never blocks ready-gate eligibility', () => {
-    // COMPLETE carries no composer-busy state anywhere; eligibility must still be true.
-    expect(evaluateReadyGateFlipEligibility(mkSummary(COMPLETE)).eligible).toBe(true)
-  })
-})