@agfpd/iapeer 0.2.76 → 0.2.78

package/src/lifecycle/lifecycle.test.ts

@@ -1,1056 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import {
-  attachPeer,
-  classifyGoneSession,
-  clearEphemeralArmed,
-  clearNewEager,
-  clearStopped,
-  composeFirstMessage,
-  countRecentDeaths,
-  folderLaunch,
-  hasEphemeralArmed,
-  hasIdleReaped,
-  hasNewEager,
-  isEphemeralPeer,
-  isLaunchdManaged,
-  isStopped,
-  lastActiveRuntime,
-  loadLifecycleConfig,
-  readDeaths,
-  readTopic,
-  recordDeath,
-  resolveWakeMode,
-  resolveWakeRuntime,
-  setEphemeralArmed,
-  setIdleReaped,
-  setNewEager,
-  setStopped,
-  superviseTick,
-  wakeOrSpawn,
-  withWakeLock,
-  writeTopic,
-  type LifecycleConfig,
-} from './index.ts'
-import { spawnSync } from 'child_process'
-import { upsertPeer, type PeerRecord } from '../registry/index.ts'
-
-function peer(over: Partial<PeerRecord>): PeerRecord {
-  return {
-    personality: 'p',
-    runtime: 'claude',
-    runtimes: ['claude'],
-    description: '',
-    intelligence: 'artificial',
-    cwd: '/tmp/p',
-    ...over,
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// H5 — resolveWakeRuntime (registry-based, no live-socket scan)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('resolveWakeRuntime (H5)', () => {
-  test('explicit declared caller runtime wins', () => {
-    const r = resolveWakeRuntime('codex', peer({ runtimes: ['claude', 'codex'] }))
-    expect(r.ok && r.value).toBe('codex')
-  })
-
-  test('explicit UNDECLARED caller runtime → fail-loud (no silent claude)', () => {
-    const r = resolveWakeRuntime('codex', peer({ runtime: 'claude', runtimes: ['claude'] }))
-    expect(r.ok).toBe(false)
-  })
-
-  test('no caller runtime → peer.runtime (registry default)', () => {
-    const r = resolveWakeRuntime(undefined, peer({ runtime: 'codex', runtimes: ['codex', 'claude'] }))
-    expect(r.ok && r.value).toBe('codex')
-  })
-
-  test('no caller runtime, no peer.runtime → first of runtimes[]', () => {
-    const r = resolveWakeRuntime(undefined, peer({ runtime: '' as never, runtimes: ['codex'] }))
-    expect(r.ok && r.value).toBe('codex')
-  })
-
-  test('nothing to pick → fail-loud', () => {
-    const r = resolveWakeRuntime(undefined, peer({ runtime: '' as never, runtimes: [] }))
-    expect(r.ok).toBe(false)
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// H4 — isLaunchdManaged on the LIVE fleet (read-only)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('isLaunchdManaged (H4 detector)', () => {
-  // HERMETIC: point the detector at a TEMP LaunchAgents dir (IAPEER_LAUNCHAGENTS_DIR),
-  // never the live ~/Library/LaunchAgents — so the test fires identically on CI and any
-  // host, not just one where the timer peer happens to be installed.
-  let laDir: string
-  beforeEach(() => {
-    laDir = mkdtempSync(join(tmpdir(), 'iapeer-h4-'))
-  })
-  afterEach(() => {
-    rmSync(laDir, { recursive: true, force: true })
-  })
-
-  test('a com.iapeer.<p>.plist present in the LaunchAgents dir → true (read-only managed)', () => {
-    writeFileSync(join(laDir, 'com.iapeer.timer.plist'), '')
-    expect(isLaunchdManaged('timer', { IAPEER_LAUNCHAGENTS_DIR: laDir } as NodeJS.ProcessEnv)).toBe(true)
-  })
-
-  test('no plist in the dir → false (daemon-owned, not launchd-managed)', () => {
-    expect(isLaunchdManaged('iapeer-throwaway-no-plist-xyz', { IAPEER_LAUNCHAGENTS_DIR: laDir } as NodeJS.ProcessEnv)).toBe(false)
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// withWakeLock — serializes per identity (concurrent = one at a time)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('withWakeLock', () => {
-  let stateDir: string
-  beforeEach(() => {
-    stateDir = mkdtempSync(join(tmpdir(), 'iapeer-wakelock-'))
-  })
-  afterEach(() => {
-    rmSync(stateDir, { recursive: true, force: true })
-  })
-
-  const cfg = (): LifecycleConfig =>
-    ({
-      claudeBin: 'claude',
-      codexBin: 'codex',
-      sockDir: '/tmp',
-      stateDir,
-      logDir: stateDir,
-      bootDeadlineSecs: 1,
-      readyGateSecs: 1,
-      idleSecs: 1,
-    }) as LifecycleConfig
-
-  test('two concurrent locks on the same identity run strictly serialized', async () => {
-    const order: string[] = []
-    const sleep = (ms: number) => new Promise(r => setTimeout(r, ms))
-    const p1 = withWakeLock(cfg(), 'claude-x', async () => {
-      order.push('1-start')
-      await sleep(150)
-      order.push('1-end')
-    })
-    // ensure p1 grabs the lock first
-    await sleep(20)
-    const p2 = withWakeLock(cfg(), 'claude-x', async () => {
-      order.push('2-start')
-      order.push('2-end')
-    })
-    await Promise.all([p1, p2])
-    expect(order).toEqual(['1-start', '1-end', '2-start', '2-end'])
-  })
-
-  test('locks on DIFFERENT identities do not block each other', async () => {
-    const order: string[] = []
-    const sleep = (ms: number) => new Promise(r => setTimeout(r, ms))
-    const a = withWakeLock(cfg(), 'claude-a', async () => {
-      order.push('a-start')
-      await sleep(120)
-      order.push('a-end')
-    })
-    await sleep(20)
-    const b = withWakeLock(cfg(), 'claude-b', async () => {
-      order.push('b-start') // must interleave — different lock
-    })
-    await Promise.all([a, b])
-    expect(order.indexOf('b-start')).toBeLessThan(order.indexOf('a-end'))
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// superviseTick — H4 guard FIRST (safe: temp LaunchAgents dir, no real fleet)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('superviseTick H4 guard', () => {
-  let stateDir: string
-  let laDir: string
-  beforeEach(() => {
-    stateDir = mkdtempSync(join(tmpdir(), 'iapeer-sup-state-'))
-    laDir = mkdtempSync(join(tmpdir(), 'iapeer-sup-la-'))
-  })
-  afterEach(() => {
-    rmSync(stateDir, { recursive: true, force: true })
-    rmSync(laDir, { recursive: true, force: true })
-  })
-
-  const cfg = (): LifecycleConfig =>
-    ({
-      claudeBin: 'claude',
-      codexBin: 'codex',
-      sockDir: '/tmp',
-      stateDir,
-      logDir: stateDir,
-      eventLogDir: stateDir, // isolate the decision log into the temp dir (no real-root leak)
-      bootDeadlineSecs: 1,
-      readyGateSecs: 1,
-      idleSecs: 1,
-    }) as LifecycleConfig
-
-  function writeState(personality: string): string {
-    const identity = `claude-${personality}`
-    writeFileSync(
-      join(stateDir, `${identity}.session`),
-      JSON.stringify({ identity, runtime: 'claude', personality, cwd: '/tmp/none', wokeAt: 0 }),
-    )
-    return identity
-  }
-  const env = () => ({ ...process.env, IAPEER_LAUNCHAGENTS_DIR: laDir })
-
-  test('a launchd-managed peer (plist present) is SKIPPED first — never reaped', () => {
-    // a fake plist in the TEMP LaunchAgents dir (real ~/Library is untouched)
-    writeFileSync(join(laDir, 'com.iapeer.iapeer-fakelaunchd.plist'), '')
-    const id = writeState('iapeer-fakelaunchd')
-    const out = superviseTick(cfg(), { env: env(), nowMs: Date.now() })
-    const o = out.find(x => x.identity === id)
-    expect(o?.action).toBe('skipped-launchd')
-    // read-only: its session-state is NOT removed
-    expect(existsSync(join(stateDir, `${id}.session`))).toBe(true)
-  })
-
-  test('a STOPPED peer with a dead session → skipped-stopped: no death record, park marker ensured', () => {
-    // boris repro (10.06): `iapeer stop` → next tick used to tag reaped-gone
-    // death=server-dead + recordDeath → post-start wake came up FRESH. A deliberate
-    // stop is a clean park the daemon knows 100% — never a death.
-    const c = cfg()
-    const id = writeState('iapeer-supstopped')
-    setStopped(c, id)
-    const out = superviseTick(c, { env: env(), nowMs: Date.now() })
-    const o = out.find(x => x.identity === id)
-    expect(o?.action).toBe('skipped-stopped')
-    expect(existsSync(join(stateDir, `${id}.session`))).toBe(false) // state dropped quietly
-    expect(readDeaths(c, id).length).toBe(0) // NOT a death — crash-loop ring untouched
-    expect(hasIdleReaped(c, id)).toBe(true) // clean park → post-start wake resumes
-    const logged = readFileSync(join(c.eventLogDir, 'lifecycle.log'), 'utf8')
-    expect(logged).toContain(`identity=${id} action=skipped-stopped`)
-    expect(logged).not.toContain('death=') // no death class for a deliberate stop
-  })
-
-  test('a no-plist peer with a dead session → reaped-gone, state removed', () => {
-    const c = cfg()
-    const id = writeState('iapeer-supgone') // no plist, no live tmux session
-    const out = superviseTick(c, { env: env(), nowMs: Date.now() })
-    const o = out.find(x => x.identity === id)
-    expect(o?.action).toBe('reaped-gone')
-    expect(existsSync(join(stateDir, `${id}.session`))).toBe(false)
-    // the decision leaves a DURABLE trace line (the observability contract) — and it
-    // lands in the SANDBOXED eventLogDir, never the real ~/.iapeer.
-    const logged = readFileSync(join(c.eventLogDir, 'lifecycle.log'), 'utf8')
-    expect(logged).toContain(`ev=supervise identity=${id} action=reaped-gone`)
-    expect(logged).toContain('outcome=fresh-next-msg')
-    // death-class tag: no socket file at all in this sandbox → the server is gone
-    expect(logged).toContain('death=server-dead')
-  })
-
-  test('empty state dir → no outcomes', () => {
-    expect(superviseTick(cfg(), { env: env() })).toEqual([])
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// wakeOrSpawn H4 — REFUSES to wake a launchd-managed peer (no spawn at all)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('wakeOrSpawn H4 refusal', () => {
-  test('a launchd-managed peer is NOT woken (returns FAILED before any spawn)', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-h4-root-'))
-    const laDir = mkdtempSync(join(tmpdir(), 'iapeer-h4-la-'))
-    try {
-      // a registered peer that ALSO has a (fake) launchd plist → launchd domain
-      writeFileSync(join(laDir, 'com.iapeer.iapeer-h4ld.plist'), '')
-      await upsertPeer(
-        { personality: 'iapeer-h4ld', runtime: 'claude', cwd: '/tmp/none', intelligence: 'artificial' },
-        { rootDir: root },
-      )
-      const env = { ...process.env, IAPEER_ROOT: root, IAPEER_LAUNCHAGENTS_DIR: laDir }
-      const r = await wakeOrSpawn({ personality: 'iapeer-h4ld', runtime: 'claude', task: 'must not spawn' }, { env })
-      expect(r.status).toBe('FAILED')
-      expect(r.woke).toBe(false)
-      expect(r.reason).toMatch(/launchd-managed/)
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// wakeOrSpawn live-session fast path — marks the caller's task as NOT delivered
-// (the concurrent-sender envelope-loss seam: routeSend redelivers on this flag)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('wakeOrSpawn live-session fast path', () => {
-  // Live tmux required (spawns a real session). Skipped where tmux is absent — a
-  // clean CI runner has none; the foundation's preversion gate runs it locally
-  // (this machine has tmux), so the release path keeps the coverage.
-  const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0
-  test.if(tmuxAvailable)('READY with taskDelivered:false — the winning wake delivered only ITS envelope', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-fpl-root-'))
-    const laDir = mkdtempSync(join(tmpdir(), 'iapeer-fpl-la-')) // empty → not launchd-managed
-    const sockDir = join(root, 'socks')
-    const sock = join(sockDir, 'tmux-iap-claude-fpl.sock')
-    try {
-      mkdirSync(sockDir, { recursive: true })
-      await upsertPeer(
-        { personality: 'fpl', runtime: 'claude', cwd: root, intelligence: 'artificial' },
-        { rootDir: root },
-      )
-      // a live session already up — what a WINNING concurrent wake leaves behind
-      const up = spawnSync('tmux', ['-S', sock, 'new-session', '-d', '-s', 'claude-fpl', 'cat'], { encoding: 'utf8' })
-      expect(up.status).toBe(0)
-      const env = { ...process.env, IAPEER_ROOT: root, IAPEER_LAUNCHAGENTS_DIR: laDir }
-      const r = await wakeOrSpawn({ personality: 'fpl', runtime: 'claude', task: 'second sender envelope' }, { env })
-      expect(r.status).toBe('READY')
-      expect(r.woke).toBe(false)
-      // the contract under test: the fast path NEVER delivers the caller's task
-      expect(r.taskDelivered).toBe(false)
-    } finally {
-      spawnSync('tmux', ['-S', sock, 'kill-server'], { encoding: 'utf8' })
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// C1 — durable stopped flag (stop/start; daemon refuses to wake a stopped peer)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('C1 durable stopped flag', () => {
-  test('isStopped/setStopped/clearStopped round-trip', () => {
-    const stateDir = mkdtempSync(join(tmpdir(), 'iapeer-stopped-'))
-    const cfg = { stateDir } as LifecycleConfig
-    try {
-      expect(isStopped(cfg, 'claude-x')).toBe(false)
-      setStopped(cfg, 'claude-x')
-      expect(isStopped(cfg, 'claude-x')).toBe(true)
-      clearStopped(cfg, 'claude-x')
-      expect(isStopped(cfg, 'claude-x')).toBe(false)
-    } finally {
-      rmSync(stateDir, { recursive: true, force: true })
-    }
-  })
-
-  test('wakeOrSpawn REFUSES a stopped peer (FAILED stopped:true, before any spawn)', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-stp-root-'))
-    const laDir = mkdtempSync(join(tmpdir(), 'iapeer-stp-la-')) // empty → not launchd-managed
-    try {
-      await upsertPeer(
-        { personality: 'stp', runtime: 'claude', cwd: '/tmp/none', intelligence: 'artificial' },
-        { rootDir: root },
-      )
-      const env = { ...process.env, IAPEER_ROOT: root, IAPEER_LAUNCHAGENTS_DIR: laDir }
-      const cfg = loadLifecycleConfig(env)
-      setStopped(cfg, 'claude-stp')
-      const r = await wakeOrSpawn({ personality: 'stp', runtime: 'claude', task: 'must not wake' }, { env })
-      expect(r.status).toBe('FAILED')
-      expect(r.stopped).toBe(true)
-      expect(r.reason).toMatch(/stopped/)
-      // cleared → wakeable again (it will then FAIL later for the missing cwd, NOT stopped)
-      clearStopped(cfg, 'claude-stp')
-      const r2 = await wakeOrSpawn({ personality: 'stp', runtime: 'claude', task: 'x' }, { env })
-      expect(r2.stopped).toBeFalsy()
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// C2 — initial_prompt launch-seed (composeFirstMessage)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('C2 initial_prompt (composeFirstMessage)', () => {
-  function withProfile(initial_prompt?: string): string {
-    const cwd = mkdtempSync(join(tmpdir(), 'iapeer-seed-'))
-    mkdirSync(join(cwd, '.iapeer'), { recursive: true })
-    writeFileSync(
-      join(cwd, '.iapeer', 'peer-profile.json'),
-      JSON.stringify({
-        personality: 'p',
-        runtime: 'claude',
-        runtimes: ['claude'],
-        intelligence: 'artificial',
-        ...(initial_prompt ? { initial_prompt } : {}),
-      }),
-    )
-    return cwd
-  }
-
-  test('fresh wake + initial_prompt → seed THEN task (both, seed first)', () => {
-    const cwd = withProfile('First, read STATE.md.')
-    try {
-      expect(composeFirstMessage(cwd, '<iap>msg</iap>', true)).toBe('First, read STATE.md.\n\n<iap>msg</iap>')
-    } finally {
-      rmSync(cwd, { recursive: true, force: true })
-    }
-  })
-
-  test('resume (fresh=false) → task only, no seed', () => {
-    const cwd = withProfile('First, read STATE.md.')
-    try {
-      expect(composeFirstMessage(cwd, 'TASK', false)).toBe('TASK')
-    } finally {
-      rmSync(cwd, { recursive: true, force: true })
-    }
-  })
-
-  test('fresh wake, NO initial_prompt → task only', () => {
-    const cwd = withProfile(undefined)
-    try {
-      expect(composeFirstMessage(cwd, 'TASK', true)).toBe('TASK')
-    } finally {
-      rmSync(cwd, { recursive: true, force: true })
-    }
-  })
-
-  test('fresh with seed but EMPTY task (eager /new) → seed alone (no trailing)', () => {
-    const cwd = withProfile('Report you are up.')
-    try {
-      expect(composeFirstMessage(cwd, '', true)).toBe('Report you are up.')
-    } finally {
-      rmSync(cwd, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// resolveWakeMode — TARGET redesign (daemon decides fresh-vs-resume by DEATH CAUSE
-// = .idle-reaped marker, plus peer-type/topic; NO agent-dropped fresh mark).
-// ─────────────────────────────────────────────────────────────────────────────
-
-/** A temp cwd with a peer-profile; interfaces.telegram present → human-conversational;
- *  ephemeral → wake_policy "ephemeral". */
-function profileCwd(human: boolean, ephemeral = false): string {
-  const cwd = mkdtempSync(join(tmpdir(), 'iapeer-wm-cwd-'))
-  mkdirSync(join(cwd, '.iapeer'), { recursive: true })
-  writeFileSync(
-    join(cwd, '.iapeer', 'peer-profile.json'),
-    JSON.stringify({
-      personality: 'p',
-      runtime: 'claude',
-      runtimes: ['claude'],
-      intelligence: human ? 'natural' : 'artificial',
-      ...(human ? { interfaces: { telegram: { user_id: 1 } } } : {}),
-      ...(ephemeral ? { wake_policy: 'ephemeral' } : {}),
-    }),
-  )
-  return cwd
-}
-
-describe('resolveWakeMode (TARGET: death-cause + peer-type/topic)', () => {
-  let stateDir: string
-  let cwds: string[]
-  beforeEach(() => {
-    stateDir = mkdtempSync(join(tmpdir(), 'iapeer-wakemode-'))
-    cwds = []
-  })
-  afterEach(() => {
-    rmSync(stateDir, { recursive: true, force: true })
-    for (const c of cwds) rmSync(c, { recursive: true, force: true })
-  })
-  const cfg = () => ({ stateDir } as LifecycleConfig)
-  const cwd = (human = false, ephemeral = false) => {
-    const c = profileCwd(human, ephemeral)
-    cwds.push(c)
-    return c
-  }
-  const hasTranscript = () => ({ ok: true, ref: 'uuid-1' })
-  const noTranscript = () => ({ ok: false, reason: 'no transcript to resume' })
-
-  // ── branch 1/2: explicit fresh / explicit resume (unchanged) ────────────────
-  test('argsResume=false (folder-launch) → FRESH', () => {
-    expect(resolveWakeMode(cfg(), 'claude-p', cwd(), false, hasTranscript)).toEqual({ resume: false, cause: 'folder-launch' })
-  })
-  test('argsResume=true (attach) + transcript → RESUME', () => {
-    expect(resolveWakeMode(cfg(), 'claude-p', cwd(), true, hasTranscript)).toEqual({ resume: true, resumeRef: 'uuid-1', cause: 'attach' })
-  })
-  test('argsResume=true + nothing to resume → FAIL-LOUD (failReason, no silent fresh)', () => {
-    const m = resolveWakeMode(cfg(), 'claude-p', cwd(), true, noTranscript)
-    expect(m.resume).toBe(false)
-    expect(m.failReason).toMatch(/nothing to resume|no transcript/)
-  })
-
-  // ── branch 3a: default + NOT idle-reaped → it died on its own → FRESH ────────
-  test('DEFAULT + NOT idle-reaped (crash/self-close) → FRESH even when a transcript exists', () => {
-    // INVERSION of the old polarity: absence of the daemon's idle-reaped marker = died
-    // on its own = clean fresh, NOT a resume of a possibly-broken context.
-    expect(resolveWakeMode(cfg(), 'claude-p', cwd(), undefined, hasTranscript)).toEqual({ resume: false, cause: 'crash-or-self-close' })
-  })
-
-  test('DEFAULT + NOT idle-reaped + NO transcript at all → FRESH with cause=first-wake (not a crash)', () => {
-    // boris finding (10.06): the first-ever wake of a freshly created peer used to
-    // read crash-or-self-close — a mis-classification. No transcript = never ran.
-    expect(resolveWakeMode(cfg(), 'claude-p', cwd(), undefined, noTranscript)).toEqual({ resume: false, cause: 'first-wake' })
-  })
-
-  // ── stop→start is a CLEAN PARK (boris 10.06): the park marker → RESUME ────────
-  test('stop→start path: clean-park marker set by stop → the next default wake RESUMES', () => {
-    const c = cfg()
-    setIdleReaped(c, 'claude-p') // what the stop verb writes before killing
-    expect(resolveWakeMode(c, 'claude-p', cwd(false), undefined, hasTranscript)).toEqual({ resume: true, resumeRef: 'uuid-1', cause: 'idle-reaped-resume' })
-  })
-
-  // ── branch 3b: default + idle-reaped → resume-eligible, CONSUME the marker ───
-  test('DEFAULT + idle-reaped + human-conversational (interfaces.telegram) → RESUME, marker consumed', () => {
-    const c = cfg()
-    setIdleReaped(c, 'claude-p')
-    const human = cwd(true)
-    expect(resolveWakeMode(c, 'claude-p', human, undefined, hasTranscript)).toEqual({ resume: true, resumeRef: 'uuid-1', cause: 'idle-reaped-human' })
-    expect(hasIdleReaped(c, 'claude-p')).toBe(false) // consumed
-  })
-  test('DEFAULT + idle-reaped + executor + NO incoming topic → RESUME (continue the work)', () => {
-    const c = cfg()
-    setIdleReaped(c, 'claude-p')
-    expect(resolveWakeMode(c, 'claude-p', cwd(false), undefined, hasTranscript)).toEqual({ resume: true, resumeRef: 'uuid-1', cause: 'idle-reaped-resume' })
-  })
-  test('DEFAULT + idle-reaped + executor + SAME topic → RESUME', () => {
-    const c = cfg()
-    setIdleReaped(c, 'claude-p')
-    writeTopic(c, 'claude-p', 'deploy')
-    expect(resolveWakeMode(c, 'claude-p', cwd(false), undefined, hasTranscript, 'deploy')).toEqual({ resume: true, resumeRef: 'uuid-1', cause: 'idle-reaped-resume' })
-  })
-  test('DEFAULT + idle-reaped + executor + DIFFERENT topic → FRESH (new work), marker consumed', () => {
-    const c = cfg()
-    setIdleReaped(c, 'claude-p')
-    writeTopic(c, 'claude-p', 'deploy')
-    expect(resolveWakeMode(c, 'claude-p', cwd(false), undefined, hasTranscript, 'unrelated-bug')).toEqual({ resume: false, cause: 'idle-reaped-new-topic' })
-    expect(hasIdleReaped(c, 'claude-p')).toBe(false) // consumed even on the fresh executor branch
-  })
-
-  // ── M1: wake_policy "ephemeral" → ALWAYS fresh on delivery, overrides resume ──
-  test('DEFAULT + ephemeral → FRESH (ephemeral-policy), even with a resumable transcript', () => {
-    expect(resolveWakeMode(cfg(), 'claude-p', cwd(false, true), undefined, hasTranscript)).toEqual({ resume: false, cause: 'ephemeral-policy' })
-  })
-  test('DEFAULT + ephemeral + idle-reaped → FRESH (overrides idle-reaped-resume), marker consumed', () => {
-    const c = cfg()
-    setIdleReaped(c, 'claude-p')
-    expect(resolveWakeMode(c, 'claude-p', cwd(false, true), undefined, hasTranscript)).toEqual({ resume: false, cause: 'ephemeral-policy' })
-    expect(hasIdleReaped(c, 'claude-p')).toBe(false) // stray marker consumed
-  })
-  test('DEFAULT + ephemeral + telegram (human) → FRESH (ephemeral WINS over human type)', () => {
-    const c = cfg()
-    setIdleReaped(c, 'claude-p')
-    expect(resolveWakeMode(c, 'claude-p', cwd(true, true), undefined, hasTranscript)).toEqual({ resume: false, cause: 'ephemeral-policy' })
-  })
-  test('ephemeral does NOT hijack explicit attach (argsResume=true still resumes)', () => {
-    // attach is an operator action; ephemeral only governs the delivery path.
-    expect(resolveWakeMode(cfg(), 'claude-p', cwd(false, true), true, hasTranscript)).toEqual({ resume: true, resumeRef: 'uuid-1', cause: 'attach' })
-  })
-})
-
-describe('idle-reaped marker round-trip', () => {
-  test('set/has/clear', () => {
-    const stateDir = mkdtempSync(join(tmpdir(), 'iapeer-idlereap-'))
-    const cfg = { stateDir } as LifecycleConfig
-    try {
-      expect(hasIdleReaped(cfg, 'claude-y')).toBe(false)
-      setIdleReaped(cfg, 'claude-y')
-      expect(hasIdleReaped(cfg, 'claude-y')).toBe(true)
-    } finally {
-      rmSync(stateDir, { recursive: true, force: true })
-    }
-  })
-})
-
-describe('new-eager marker round-trip', () => {
-  test('set/has/clear', () => {
-    const stateDir = mkdtempSync(join(tmpdir(), 'iapeer-neweager-'))
-    const cfg = { stateDir } as LifecycleConfig
-    try {
-      expect(hasNewEager(cfg, 'claude-y')).toBe(false)
-      setNewEager(cfg, 'claude-y')
-      expect(hasNewEager(cfg, 'claude-y')).toBe(true)
-      clearNewEager(cfg, 'claude-y')
-      expect(hasNewEager(cfg, 'claude-y')).toBe(false)
-    } finally {
-      rmSync(stateDir, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// superviseTick — death-cause accounting (TARGET redesign)
-//  • idle-reap is the ONLY place .idle-reaped is written
-//  • a crash/self-close death writes NO marker (lazy fresh on next message)
-//  • a dead session carrying .new-eager → needs-eager-fresh (mark LEFT for relaunch)
-//  • every dead session records a death (crash-loop accounting)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('superviseTick death-cause accounting (TARGET)', () => {
-  function deadSessionEnv(personality: string): { env: NodeJS.ProcessEnv; cfg: LifecycleConfig; root: string; laDir: string } {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-sup-tgt-root-'))
-    const laDir = mkdtempSync(join(tmpdir(), 'iapeer-sup-tgt-la-')) // empty → not launchd-managed
-    const env = { ...process.env, IAPEER_ROOT: root, IAPEER_LAUNCHAGENTS_DIR: laDir, IAPEER_SOCK_DIR: join(root, 'socks') }
-    const cfg = loadLifecycleConfig(env)
-    mkdirSync(cfg.stateDir, { recursive: true })
-    writeFileSync(
-      join(cfg.stateDir, `claude-${personality}.session`),
-      JSON.stringify({ identity: `claude-${personality}`, runtime: 'claude', personality, cwd: `/tmp/${personality}`, wokeAt: Date.now() }),
-    )
-    return { env, cfg, root, laDir }
-  }
-
-  test('a DEAD session carrying .new-eager → needs-eager-fresh (mark LEFT for relaunch), death recorded', () => {
-    const { env, cfg, root, laDir } = deadSessionEnv('z')
-    try {
-      setNewEager(cfg, 'claude-z')
-      const out = superviseTick(cfg, { env })
-      const o = out.find(x => x.identity === 'claude-z')
-      expect(o?.action).toBe('needs-eager-fresh')
-      expect(o?.personality).toBe('z')
-      expect(o?.runtime).toBe('claude')
-      // the eager mark is LEFT for processEagerRelaunches to consume
-      expect(hasNewEager(cfg, 'claude-z')).toBe(true)
-      // every dead session records a death for the crash-loop ring
-      expect(readDeaths(cfg, 'claude-z').length).toBe(1)
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-    }
-  })
-
-  test('eager relaunch does NOT pin the dead session runtime — re-resolves from the registry (H5 fleet-switch)', async () => {
-    // Live incident 12.06: `default-runtime codex` + `self-fresh` resurrected the peer
-    // on the OLD runtime — the relaunch passed the dead session's runtime EXPLICITLY,
-    // so resolveWakeRuntime never consulted the just-flipped registry default.
-    const { env, cfg, root, laDir } = deadSessionEnv('rt')
-    try {
-      setNewEager(cfg, 'claude-rt')
-      const outcomes = superviseTick(cfg, { env })
-      const o = outcomes.find(x => x.identity === 'claude-rt')
-      expect(o?.action).toBe('needs-eager-fresh')
-      const seen: Array<{ personality: string; runtime?: string; resume?: boolean; task: string }> = []
-      const { processEagerRelaunches } = await import('./index.ts')
-      await processEagerRelaunches(cfg, outcomes, {
-        env,
-        wakeFn: async args => {
-          seen.push({ personality: args.personality, runtime: args.runtime, resume: args.resume, task: args.task })
-          return { status: 'READY', woke: true }
-        },
-      })
-      expect(seen.length).toBe(1)
-      expect(seen[0].personality).toBe('rt')
-      expect(seen[0].runtime).toBeUndefined() // ← the fix: wakeOrSpawn re-resolves from the registry
-      expect(seen[0].resume).toBe(false)
-      expect(seen[0].task).toBe('')
-      // the mark was consumed by the relaunch
-      expect(hasNewEager(cfg, 'claude-rt')).toBe(false)
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-    }
-  })
-
-  test('a DEAD session with NO .new-eager → reaped-gone, NO .idle-reaped written (crash leaves no marker)', () => {
-    const { env, cfg, root, laDir } = deadSessionEnv('w')
-    try {
-      const out = superviseTick(cfg, { env })
-      expect(out.find(x => x.identity === 'claude-w')?.action).toBe('reaped-gone')
-      // a crash/self-close is NOT daemon-initiated → no idle-reaped marker → next wake FRESH
-      expect(hasIdleReaped(cfg, 'claude-w')).toBe(false)
-      expect(readDeaths(cfg, 'claude-w').length).toBe(1)
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-    }
-  })
-
-  test('a DEAD session clears a stale .ephemeral-armed (the mark dies with its session)', () => {
-    // The mark armed on the dead session's outbound; were it to survive, the NEXT
-    // session would be quiet-reap eligible BEFORE answering its own task.
-    const { env, cfg, root, laDir } = deadSessionEnv('q')
-    try {
-      setEphemeralArmed(cfg, 'claude-q')
-      const out = superviseTick(cfg, { env })
-      expect(out.find(x => x.identity === 'claude-q')?.action).toBe('reaped-gone')
-      expect(hasEphemeralArmed(cfg, 'claude-q')).toBe(false)
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// wake_policy:ephemeral M2 — armed marker + quiet-reap (die-after-reply)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('ephemeral-armed marker + config', () => {
-  test('set/has/clear round-trip; clear is idempotent', () => {
-    const stateDir = mkdtempSync(join(tmpdir(), 'iapeer-eph-mark-'))
-    const cfg = { stateDir } as LifecycleConfig
-    try {
-      expect(hasEphemeralArmed(cfg, 'claude-e')).toBe(false)
-      setEphemeralArmed(cfg, 'claude-e')
-      expect(hasEphemeralArmed(cfg, 'claude-e')).toBe(true)
-      clearEphemeralArmed(cfg, 'claude-e')
-      clearEphemeralArmed(cfg, 'claude-e') // idempotent
-      expect(hasEphemeralArmed(cfg, 'claude-e')).toBe(false)
-    } finally {
-      rmSync(stateDir, { recursive: true, force: true })
-    }
-  })
-
-  test('ephemeralQuietSecs: default 20, env-tunable', () => {
-    expect(loadLifecycleConfig({ HOME: '/tmp' } as NodeJS.ProcessEnv).ephemeralQuietSecs).toBe(20)
-    expect(
-      loadLifecycleConfig({ HOME: '/tmp', IAPEER_EPHEMERAL_QUIET_SECS: '45' } as NodeJS.ProcessEnv)
-        .ephemeralQuietSecs,
-    ).toBe(45)
-  })
-
-  test('isEphemeralPeer keys on the cwd profile; read hiccup → false (safe default)', () => {
-    const eph = profileCwd(false, true)
-    const plain = profileCwd(false, false)
-    try {
-      expect(isEphemeralPeer(eph)).toBe(true)
-      expect(isEphemeralPeer(plain)).toBe(false)
-      expect(isEphemeralPeer('/tmp/definitely-no-such-peer-cwd')).toBe(false)
-    } finally {
-      rmSync(eph, { recursive: true, force: true })
-      rmSync(plain, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// classifyGoneSession — the death-class tag for reaped-gone (server-dead vs
-// session-gone). Live case: iapeer-memory 10.06 — the whole tmux server died
-// (SIGKILL class), exits.log stayed empty; lifecycle.log must carry the class.
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('classifyGoneSession (death-class tag)', () => {
-  const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0
-
-  test('missing socket file → server-dead', () => {
-    const r = classifyGoneSession(join(tmpdir(), 'iapeer-no-such-sock-ever.sock'))
-    expect(r.death).toBe('server-dead')
-    expect(r.reason).toContain('socket file missing')
-  })
-
-  test('hosted peer → host-framed reason, not tmux', () => {
-    // A pty-supervisor-hosted peer never had a tmux socket; the tmux-framed "socket file
-    // missing" would misattribute its death. hosted=true short-circuits to the supervisor framing.
-    const r = classifyGoneSession(join(tmpdir(), 'iapeer-no-such-sock-ever.sock'), true)
-    expect(r.death).toBe('server-dead')
-    expect(r.reason).toContain('pty host')
-    expect(r.reason).not.toContain('tmux server')
-  })
-
-  test('stale socket (file exists, nothing serves it) → server-dead', () => {
-    // The SIGKILL/OOM class: the killed server never unlinks its socket file.
-    const dir = mkdtempSync(join(tmpdir(), 'iapeer-stale-sock-'))
-    const sock = join(dir, 'tmux-iap-claude-stale.sock')
-    try {
-      writeFileSync(sock, '') // a plain file — tmux cannot connect to it
-      const r = classifyGoneSession(sock)
-      expect(r.death).toBe('server-dead')
-      expect(r.reason).toContain('stale socket')
-    } finally {
-      rmSync(dir, { recursive: true, force: true })
-    }
-  })
-
-  test.if(tmuxAvailable)('server alive but the session is not there → session-gone', () => {
-    const dir = mkdtempSync(join(tmpdir(), 'iapeer-sg-sock-'))
-    const sock = join(dir, 'tmux-iap-claude-sg.sock')
-    try {
-      // a LIVING server on the socket holding some OTHER session
-      spawnSync('tmux', ['-S', sock, 'new-session', '-d', '-s', 'other-session', 'sleep', '60'])
-      const r = classifyGoneSession(sock)
-      expect(r.death).toBe('session-gone')
-      expect(r.reason).toContain('server alive')
-    } finally {
-      spawnSync('tmux', ['-S', sock, 'kill-server'], { stdio: 'ignore' })
-      rmSync(dir, { recursive: true, force: true })
-    }
-  })
-
-  test.if(tmuxAvailable)('superviseTick logs death=session-gone when the pane died inside a living server', () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-sg-root-'))
-    const laDir = mkdtempSync(join(tmpdir(), 'iapeer-sg-la-')) // empty → not launchd-managed
-    const env = {
-      ...process.env,
-      IAPEER_ROOT: root,
-      IAPEER_LAUNCHAGENTS_DIR: laDir,
-      IAPEER_SOCK_DIR: join(root, 'socks'),
-    }
-    const cfg = loadLifecycleConfig(env)
-    const identity = 'claude-sg'
-    const sock = join(root, 'socks', 'tmux-iap-claude-sg.sock')
-    try {
-      mkdirSync(join(root, 'socks'), { recursive: true })
-      mkdirSync(cfg.stateDir, { recursive: true })
-      // the server LIVES (another session holds it) but claude-sg's session is gone
-      spawnSync('tmux', ['-S', sock, 'new-session', '-d', '-s', 'placeholder', 'sleep', '60'])
-      writeFileSync(
-        join(cfg.stateDir, `${identity}.session`),
-        JSON.stringify({ identity, runtime: 'claude', personality: 'sg', cwd: '/tmp/none', wokeAt: 0 }),
-      )
-      const out = superviseTick(cfg, { env })
-      expect(out.find(x => x.identity === identity)?.action).toBe('reaped-gone')
-      const logged = readFileSync(join(cfg.eventLogDir, 'lifecycle.log'), 'utf8')
-      expect(logged).toContain(`identity=${identity} action=reaped-gone death=session-gone`)
-    } finally {
-      spawnSync('tmux', ['-S', sock, 'kill-server'], { stdio: 'ignore' })
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-    }
-  })
-})
-
-describe('superviseTick quiet-reap (M2 die-after-reply, real tmux)', () => {
-  const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0
-
-  test.if(tmuxAvailable)(
-    'ARMED + quiet → reaped-ephemeral (killed, marks cleared, NO death/idle-reaped); unarmed/not-quiet → alive',
-    () => {
-      const root = mkdtempSync(join(tmpdir(), 'iapeer-eq-root-'))
-      const laDir = mkdtempSync(join(tmpdir(), 'iapeer-eq-la-')) // empty → not launchd-managed
-      const cwd = profileCwd(false, true) // ephemeral worker profile
-      const env = {
-        ...process.env,
-        IAPEER_ROOT: root,
-        IAPEER_LAUNCHAGENTS_DIR: laDir,
-        IAPEER_SOCK_DIR: join(root, 'socks'),
-      }
-      const cfg = loadLifecycleConfig(env) // ephemeralQuietSecs 20 ≪ idleSecs 3600
-      const identity = 'claude-eq'
-      const sock = join(root, 'socks', 'tmux-iap-claude-eq.sock')
-      const writeState = (wokeAt: number) => {
-        mkdirSync(cfg.stateDir, { recursive: true })
-        writeFileSync(
-          join(cfg.stateDir, `${identity}.session`),
-          JSON.stringify({ identity, runtime: 'claude', personality: 'eq', cwd, wokeAt }),
-        )
-      }
-      const alive = () => spawnSync('tmux', ['-S', sock, 'has-session', '-t', identity]).status === 0
-      try {
-        mkdirSync(join(root, 'socks'), { recursive: true })
-        spawnSync('tmux', ['-S', sock, 'new-session', '-d', '-s', identity, 'sleep', '300'])
-        expect(alive()).toBe(true)
-        // no transcript in the temp cwd → activity proxy = wokeAt fallback:
-        // quiet age is fully controlled by the .session wokeAt below.
-
-        // 1) NOT armed + quiet-aged → alive (a silent long tool-run is NOT reaped:
-        //    sleep-180 protection; only the ordinary idle bound applies).
-        writeState(Date.now() - 60_000) // age ~60s > quiet 20s, ≪ idle 3600s
-        expect(superviseTick(cfg, { env }).find(x => x.identity === identity)?.action).toBe('alive')
-        expect(alive()).toBe(true)
-
-        // 2) ARMED but NOT quiet → alive (post-reply housekeeping keeps it alive).
-        setEphemeralArmed(cfg, identity)
-        writeState(Date.now()) // age ~0 < quiet
-        expect(superviseTick(cfg, { env }).find(x => x.identity === identity)?.action).toBe('alive')
-        expect(alive()).toBe(true)
-
-        // 3) ARMED + quiet → reaped-ephemeral, with the M3 drain fields.
-        writeState(Date.now() - 60_000)
-        const o = superviseTick(cfg, { env }).find(x => x.identity === identity)
-        expect(o?.action).toBe('reaped-ephemeral')
-        expect(o?.personality).toBe('eq')
-        expect(o?.runtime).toBe('claude')
-        expect(alive()).toBe(false) // session killed
-        expect(hasEphemeralArmed(cfg, identity)).toBe(false) // mark consumed
-        expect(existsSync(join(cfg.stateDir, `${identity}.session`))).toBe(false)
-        // deliberate policy death: never resume-eligible, never a crash-loop count
-        expect(hasIdleReaped(cfg, identity)).toBe(false)
-        expect(readDeaths(cfg, identity).length).toBe(0)
-        // durable decision trace
-        const logged = readFileSync(join(cfg.eventLogDir, 'lifecycle.log'), 'utf8')
-        expect(logged).toContain(`action=reaped-ephemeral`)
-        expect(logged).toContain('outcome=ephemeral-done')
-      } finally {
-        spawnSync('tmux', ['-S', sock, 'kill-server'], { stdio: 'ignore' })
-        rmSync(root, { recursive: true, force: true })
-        rmSync(laDir, { recursive: true, force: true })
-        rmSync(cwd, { recursive: true, force: true })
-      }
-    },
-    30000,
-  )
-
-  test.if(tmuxAvailable)(
-    'UNARMED ephemeral past the unarmed idle bound → reaped-ephemeral (silent-finish backstop; live case scriber 10.06)',
-    () => {
-      const root = mkdtempSync(join(tmpdir(), 'iapeer-eu-root-'))
-      const laDir = mkdtempSync(join(tmpdir(), 'iapeer-eu-la-'))
-      const cwd = profileCwd(false, true) // ephemeral worker profile
-      const env = {
-        ...process.env,
-        IAPEER_ROOT: root,
-        IAPEER_LAUNCHAGENTS_DIR: laDir,
-        IAPEER_SOCK_DIR: join(root, 'socks'),
-        IAPEER_EPHEMERAL_UNARMED_IDLE_SECS: '30', // ≪ the 60s age below, ≫ quiet 20s
-      }
-      const cfg = loadLifecycleConfig(env)
-      const identity = 'claude-eu'
-      const sock = join(root, 'socks', 'tmux-iap-claude-eu.sock')
-      const alive = () => spawnSync('tmux', ['-S', sock, 'has-session', '-t', identity]).status === 0
-      try {
-        mkdirSync(join(root, 'socks'), { recursive: true })
-        spawnSync('tmux', ['-S', sock, 'new-session', '-d', '-s', identity, 'sleep', '300'])
-        expect(alive()).toBe(true)
-        mkdirSync(cfg.stateDir, { recursive: true })
-        writeFileSync(
-          join(cfg.stateDir, `${identity}.session`),
-          JSON.stringify({ identity, runtime: 'claude', personality: 'eu', cwd, wokeAt: Date.now() - 60_000 }),
-        )
-        // NOT armed (the worker ended silently) — past the unarmed bound → policy reap
-        const o = superviseTick(cfg, { env }).find(x => x.identity === identity)
-        expect(o?.action).toBe('reaped-ephemeral')
-        expect(o?.reason).toContain('unarmed idle')
-        expect(o?.personality).toBe('eu') // M3 drain fields present → queue feeds next
-        expect(alive()).toBe(false)
-        // policy death: no resume-eligibility, no crash-loop count
-        expect(hasIdleReaped(cfg, identity)).toBe(false)
-        expect(readDeaths(cfg, identity).length).toBe(0)
-        const logged = readFileSync(join(cfg.eventLogDir, 'lifecycle.log'), 'utf8')
-        expect(logged).toContain('outcome=ephemeral-unarmed-bound')
-        // a NON-ephemeral peer with the same age is untouched by this bound
-        // (its session lives on ITS OWN identity-derived socket — the tick keys
-        // sockets on runtime-personality, not on the test's prior sock)
-        const plainCwd = profileCwd(false, false)
-        const eupSock = join(root, 'socks', 'tmux-iap-claude-eup.sock')
-        try {
-          writeFileSync(
-            join(cfg.stateDir, `claude-eup.session`),
-            JSON.stringify({ identity: 'claude-eup', runtime: 'claude', personality: 'eup', cwd: plainCwd, wokeAt: Date.now() - 60_000 }),
-          )
-          spawnSync('tmux', ['-S', eupSock, 'new-session', '-d', '-s', 'claude-eup', 'sleep', '300'])
-          expect(superviseTick(cfg, { env }).find(x => x.identity === 'claude-eup')?.action).toBe('alive')
-        } finally {
-          spawnSync('tmux', ['-S', eupSock, 'kill-server'], { stdio: 'ignore' })
-          rmSync(plainCwd, { recursive: true, force: true })
-        }
-      } finally {
-        spawnSync('tmux', ['-S', sock, 'kill-server'], { stdio: 'ignore' })
-        rmSync(root, { recursive: true, force: true })
-        rmSync(laDir, { recursive: true, force: true })
-        rmSync(cwd, { recursive: true, force: true })
-      }
-    },
-    30000,
-  )
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Crash-loop guard — wakeOrSpawn refuses to (re)launch after N deaths in the window
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('crash-loop guard', () => {
-  test('countRecentDeaths windows correctly; recordDeath rings', () => {
-    const stateDir = mkdtempSync(join(tmpdir(), 'iapeer-deaths-'))
-    const cfg = { stateDir } as LifecycleConfig
-    try {
-      const now = 1_000_000
-      recordDeath(cfg, 'claude-d', now - 400_000) // outside a 300s window
-      recordDeath(cfg, 'claude-d', now - 10_000)
-      recordDeath(cfg, 'claude-d', now - 5_000)
-      expect(countRecentDeaths(cfg, 'claude-d', 300, now)).toBe(2)
-      expect(countRecentDeaths(cfg, 'claude-d', 600, now)).toBe(3)
-    } finally {
-      rmSync(stateDir, { recursive: true, force: true })
-    }
-  })
-
-  test('wakeOrSpawn REFUSES after crashLoopMax deaths within the window (FAILED, no launch)', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-clg-root-'))
-    const laDir = mkdtempSync(join(tmpdir(), 'iapeer-clg-la-')) // empty → not launchd-managed
-    const peerCwd = mkdtempSync(join(tmpdir(), 'iapeer-clg-cwd-')) // REAL cwd so the cwd-existence check passes and the guard is what fires
-    try {
-      await upsertPeer(
-        { personality: 'clg', runtime: 'claude', cwd: peerCwd, intelligence: 'artificial' },
-        { rootDir: root },
-      )
-      const env = { ...process.env, IAPEER_ROOT: root, IAPEER_LAUNCHAGENTS_DIR: laDir, IAPEER_SOCK_DIR: join(root, 'socks'), IAPEER_CRASHLOOP_MAX: '3', IAPEER_CRASHLOOP_WINDOW_SECS: '300' }
-      const cfg = loadLifecycleConfig(env)
-      const now = Date.now()
-      recordDeath(cfg, 'claude-clg', now)
-      recordDeath(cfg, 'claude-clg', now)
-      recordDeath(cfg, 'claude-clg', now)
-      const r = await wakeOrSpawn({ personality: 'clg', runtime: 'claude', task: 'must not launch' }, { env })
-      expect(r.status).toBe('FAILED')
-      expect(r.woke).toBe(false)
-      expect(r.reason).toMatch(/crash-loop guard/)
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-      rmSync(laDir, { recursive: true, force: true })
-      rmSync(peerCwd, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// .topic — executor discriminator round-trip
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('topic marker round-trip', () => {
-  test('writeTopic/readTopic', () => {
-    const stateDir = mkdtempSync(join(tmpdir(), 'iapeer-topic-'))
-    const cfg = { stateDir } as LifecycleConfig
-    try {
-      expect(readTopic(cfg, 'claude-t')).toBe('')
-      writeTopic(cfg, 'claude-t', 'deploy-pipeline')
-      expect(readTopic(cfg, 'claude-t')).toBe('deploy-pipeline')
-    } finally {
-      rmSync(stateDir, { recursive: true, force: true })
-    }
-  })
-})
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Ф-D launch / attach — operator verbs (error paths; success paths are live-verified)
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('lastActiveRuntime', () => {
-  test('a peer with no transcript anywhere → undefined (never run)', () => {
-    const cfg = { sockDir: '/tmp' } as LifecycleConfig
-    const rt = lastActiveRuntime(peer({ personality: 'np', runtimes: ['claude', 'codex'], cwd: '/tmp/does-not-exist-xyz' }), cfg)
-    expect(rt).toBeUndefined()
-  })
-})
-
-describe('attachPeer (error paths)', () => {
-  test('an unregistered peer → ok:false', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-att-'))
-    try {
-      const r = await attachPeer({ personality: 'ghost', env: { ...process.env, IAPEER_ROOT: root } })
-      expect(r.ok).toBe(false)
-      if (!r.ok) expect(r.reason).toMatch(/not registered/)
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-    }
-  })
-  test('an explicit UNDECLARED runtime → ok:false (fail-loud)', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-att2-'))
-    try {
-      await upsertPeer({ personality: 'solo', runtime: 'claude', cwd: '/tmp/solo', intelligence: 'artificial' }, { rootDir: root })
-      const r = await attachPeer({ personality: 'solo', runtime: 'codex', env: { ...process.env, IAPEER_ROOT: root } })
-      expect(r.ok).toBe(false)
-    } finally {
-      rmSync(root, { recursive: true, force: true })
-    }
-  })
-})
-
-describe('folderLaunch (error path)', () => {
-  test('a cwd without a peer-profile → throws (resolveIdentity fail-loud)', async () => {
-    const cwd = mkdtempSync(join(tmpdir(), 'iapeer-fl-'))
-    try {
-      await expect(folderLaunch({ cwd, env: { ...process.env } })).rejects.toThrow()
-    } finally {
-      rmSync(cwd, { recursive: true, force: true })
-    }
-  })
-})