@agfpd/iapeer 0.2.77 → 0.2.78

package/src/launch/nativeMemory.test.ts

@@ -1,193 +0,0 @@
-// Native runtime-memory levers — the canonized forms (slot contract §Native-
-// память). The HARD requirement pinned here: NO-CLOBBER — both target files
-// carry foreign blocks (plugin enables, statusline wrappers) that every lever
-// write must preserve byte-meaningfully.
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import {
-  applyNativeMemory,
-  claudeSettingsPath,
-  codexProjectConfigPath,
-  codexGlobalConfigPath,
-  preTrustCodexCwd,
-  removeCodexCwdTrust,
-} from './nativeMemory.ts'
-
-const dirs: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-natmem-'))
-  dirs.push(d)
-  return d
-}
-afterEach(() => {
-  while (dirs.length) rmSync(dirs.pop()!, { recursive: true, force: true })
-})
-
-describe('claude lever (settings.json merge)', () => {
-  test('absent file → created with ONLY the lever key', () => {
-    const cwd = mkTmp()
-    const [o] = applyNativeMemory(cwd, ['claude'], 'off')
-    expect(o?.state).toBe('written')
-    expect(JSON.parse(readFileSync(claudeSettingsPath(cwd), 'utf8'))).toEqual({ autoMemoryEnabled: false })
-  })
-
-  test('NO-CLOBBER: foreign keys (plugins, statusline) survive off AND on', () => {
-    const cwd = mkTmp()
-    mkdirSync(join(cwd, '.claude'), { recursive: true })
-    const foreign = { enabledPlugins: { 'MergeMind@agfpd': true }, statusLine: { type: 'command', command: 'x' } }
-    writeFileSync(claudeSettingsPath(cwd), JSON.stringify(foreign))
-    applyNativeMemory(cwd, ['claude'], 'off')
-    const afterOff = JSON.parse(readFileSync(claudeSettingsPath(cwd), 'utf8'))
-    expect(afterOff).toEqual({ ...foreign, autoMemoryEnabled: false })
-    const [on] = applyNativeMemory(cwd, ['claude'], 'on')
-    expect(on?.state).toBe('written')
-    expect(JSON.parse(readFileSync(claudeSettingsPath(cwd), 'utf8'))).toEqual(foreign) // key REMOVED, default restored
-  })
-
-  test('idempotent: already-false → already; on with no key → already', () => {
-    const cwd = mkTmp()
-    applyNativeMemory(cwd, ['claude'], 'off')
-    expect(applyNativeMemory(cwd, ['claude'], 'off')[0]?.state).toBe('already')
-    applyNativeMemory(cwd, ['claude'], 'on')
-    expect(applyNativeMemory(cwd, ['claude'], 'on')[0]?.state).toBe('already')
-  })
-
-  test('non-object settings.json → failed (refuses to clobber), file untouched', () => {
-    const cwd = mkTmp()
-    mkdirSync(join(cwd, '.claude'), { recursive: true })
-    writeFileSync(claudeSettingsPath(cwd), '"just a string"')
-    const [o] = applyNativeMemory(cwd, ['claude'], 'off')
-    expect(o?.state).toBe('failed')
-    expect(readFileSync(claudeSettingsPath(cwd), 'utf8')).toBe('"just a string"')
-  })
-})
-
-describe('codex lever (config.toml [features] merge)', () => {
-  test('absent file → [features] section with the lever line', () => {
-    const cwd = mkTmp()
-    const [o] = applyNativeMemory(cwd, ['codex'], 'off')
-    expect(o?.state).toBe('written')
-    expect(readFileSync(codexProjectConfigPath(cwd), 'utf8')).toBe('[features]\nmemories = false\n')
-  })
-
-  test('NO-CLOBBER: plugin blocks survive; [features] appended after them (fleet-file shape)', () => {
-    const cwd = mkTmp()
-    mkdirSync(join(cwd, '.codex'), { recursive: true })
-    const fleet = '[plugins."Inter-Agent-Protocol@agfpd"]\nenabled = true\n\n[plugins."MergeMind@agfpd"]\nenabled = true\n'
-    writeFileSync(codexProjectConfigPath(cwd), fleet)
-    applyNativeMemory(cwd, ['codex'], 'off')
-    const text = readFileSync(codexProjectConfigPath(cwd), 'utf8')
-    expect(text).toContain('[plugins."Inter-Agent-Protocol@agfpd"]\nenabled = true')
-    expect(text).toContain('[plugins."MergeMind@agfpd"]\nenabled = true')
-    expect(text).toContain('[features]\nmemories = false')
-  })
-
-  test('existing [features] WITHOUT memories (followed by another section) → inserted INSIDE the section', () => {
-    const cwd = mkTmp()
-    mkdirSync(join(cwd, '.codex'), { recursive: true })
-    writeFileSync(codexProjectConfigPath(cwd), '[features]\nother = true\n\n[plugins."X@y"]\nenabled = true\n')
-    applyNativeMemory(cwd, ['codex'], 'off')
-    const text = readFileSync(codexProjectConfigPath(cwd), 'utf8')
-    // the lever line lands in [features], NOT in [plugins."X@y"]
-    expect(text.indexOf('memories = false')).toBeLessThan(text.indexOf('[plugins."X@y"]'))
-    expect(text).toContain('other = true')
-  })
-
-  test('memories = true → replaced with false; already false → already', () => {
-    const cwd = mkTmp()
-    mkdirSync(join(cwd, '.codex'), { recursive: true })
-    writeFileSync(codexProjectConfigPath(cwd), '[features]\nmemories = true\n')
-    expect(applyNativeMemory(cwd, ['codex'], 'off')[0]?.state).toBe('written')
-    expect(readFileSync(codexProjectConfigPath(cwd), 'utf8')).toContain('memories = false')
-    expect(applyNativeMemory(cwd, ['codex'], 'off')[0]?.state).toBe('already')
-  })
-
-  test('on → the memories line is REMOVED (default restored), section + foreign lines kept', () => {
-    const cwd = mkTmp()
-    mkdirSync(join(cwd, '.codex'), { recursive: true })
-    writeFileSync(codexProjectConfigPath(cwd), '[features]\nmemories = false\nother = true\n')
-    const [o] = applyNativeMemory(cwd, ['codex'], 'on')
-    expect(o?.state).toBe('written')
-    const text = readFileSync(codexProjectConfigPath(cwd), 'utf8')
-    expect(text).not.toContain('memories')
-    expect(text).toContain('other = true')
-    expect(applyNativeMemory(cwd, ['codex'], 'on')[0]?.state).toBe('already')
-  })
-})
-
-describe('applyNativeMemory runtime dispatch', () => {
-  test('both runtimes → both levers; router-only runtimes → no outcomes', () => {
-    const cwd = mkTmp()
-    const both = applyNativeMemory(cwd, ['claude', 'codex'], 'off')
-    expect(both.map(o => o.runtime).sort()).toEqual(['claude', 'codex'])
-    expect(applyNativeMemory(mkTmp(), ['telegram', 'notifier'], 'off')).toEqual([])
-  })
-})
-
-describe('preTrustCodexCwd (birth-time trust, codex global config)', () => {
-  test('codexGlobalConfigPath honors $CODEX_HOME first (same override set as init codexConfigPath — sandbox seam, live-caught by D4 11.06)', () => {
-    expect(codexGlobalConfigPath({ CODEX_HOME: '/sandbox/codex', HOME: '/real/home' } as NodeJS.ProcessEnv)).toBe(
-      '/sandbox/codex/config.toml',
-    )
-    expect(codexGlobalConfigPath({ HOME: '/real/home' } as NodeJS.ProcessEnv)).toBe('/real/home/.codex/config.toml')
-  })
-
-  test('appends a [projects] block once; NO-CLOBBER of existing content; idempotent', () => {
-    const home = mkTmp()
-    const env = { HOME: home } as NodeJS.ProcessEnv
-    mkdirSync(join(home, '.codex'), { recursive: true })
-    const existing = '[projects."/already/trusted"]\ntrust_level = "trusted"\n'
-    writeFileSync(codexGlobalConfigPath(env), existing)
-    const first = preTrustCodexCwd('/peers/newborn', env)
-    expect(first.state).toBe('written')
-    const text = readFileSync(codexGlobalConfigPath(env), 'utf8')
-    expect(text).toContain(existing.trim())
-    expect(text).toContain('[projects."/peers/newborn"]\ntrust_level = "trusted"')
-    expect(preTrustCodexCwd('/peers/newborn', env).state).toBe('already')
-  })
-
-  test('removeCodexCwdTrust: drops EXACTLY the peer cwd section (header+body), keeps neighbors; idempotent; handles deleted cwd via literal match', () => {
-    const home = mkTmp()
-    const env = { HOME: home } as NodeJS.ProcessEnv
-    mkdirSync(join(home, '.codex'), { recursive: true })
-    const cfg =
-      '[mcp_servers.iapeer]\nurl = "http://x"\n\n' +
-      '[projects."/keep/me"]\ntrust_level = "trusted"\n\n' +
-      '[projects."/peers/doomed"]\ntrust_level = "trusted"\n\n' +
-      '[features]\nmemories = false\n'
-    writeFileSync(codexGlobalConfigPath(env), cfg)
-    // cwd "/peers/doomed" does not exist on disk → realpath fails → literal match
-    const first = removeCodexCwdTrust('/peers/doomed', env)
-    expect(first.state).toBe('written')
-    const text = readFileSync(codexGlobalConfigPath(env), 'utf8')
-    expect(text).not.toContain('/peers/doomed')
-    expect(text).toContain('[projects."/keep/me"]\ntrust_level = "trusted"') // neighbor intact
-    expect(text).toContain('[mcp_servers.iapeer]') // foreign sections intact
-    expect(text).toContain('[features]\nmemories = false')
-    expect(removeCodexCwdTrust('/peers/doomed', env).state).toBe('already') // idempotent
-    expect(removeCodexCwdTrust('/never/was', env).state).toBe('already') // absent entry → no-op
-  })
-
-  test('removeCodexCwdTrust matches the RESOLVED path of a live symlinked cwd (writer stores realpath)', () => {
-    const home = mkTmp()
-    const env = { HOME: home } as NodeJS.ProcessEnv
-    mkdirSync(join(home, '.codex'), { recursive: true })
-    const cwd = mkTmp() // /var/folders/... on macOS — realpath differs from literal /tmp form
-    // write the entry the way preTrustCodexCwd does (by realpath)
-    preTrustCodexCwd(cwd, env)
-    expect(readFileSync(codexGlobalConfigPath(env), 'utf8')).toContain('[projects."')
-    // remove by the LITERAL cwd — must hit the resolved-form entry
-    expect(removeCodexCwdTrust(cwd, env).state).toBe('written')
-    expect(readFileSync(codexGlobalConfigPath(env), 'utf8')).not.toContain('trust_level')
-  })
-
-  test('absent global config → created with just the block', () => {
-    const home = mkTmp()
-    const env = { HOME: home } as NodeJS.ProcessEnv
-    expect(preTrustCodexCwd('/peers/first', env).state).toBe('written')
-    expect(readFileSync(codexGlobalConfigPath(env), 'utf8')).toBe('[projects."/peers/first"]\ntrust_level = "trusted"\n')
-  })
-})

package/src/launch/ptyHost.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { ptyHostEnabled } from './ptyHost.ts'
-import { readyGatePtyFlipEnabled } from './readyGateModel.ts'
-
-describe('ptyHostEnabled — pty-hosting is the DEFAULT, .no-pty-host opts out', () => {
-  test('ON by default (no marker needed); OFF when the .no-pty-host opt-out marker exists; per-peer', () => {
-    const dir = mkdtempSync(join(tmpdir(), 'ptyhost-flag-'))
-    try {
-      expect(ptyHostEnabled(dir, 'codex-x')).toBe(true) // DEFAULT: hosted out of the box, no marker
-      writeFileSync(join(dir, 'codex-x.no-pty-host'), '') // explicit opt-OUT → tmux
-      expect(ptyHostEnabled(dir, 'codex-x')).toBe(false)
-      expect(ptyHostEnabled(dir, 'codex-y')).toBe(true) // opt-out is per-peer, not global — y stays default-on
-    } finally {
-      rmSync(dir, { recursive: true, force: true })
-    }
-  })
-
-  test('legacy .pty-host opt-in marker is REDUNDANT (ignored); .pty-readygate is orthogonal; only .no-pty-host flips to tmux', () => {
-    const dir = mkdtempSync(join(tmpdir(), 'ptyhost-distinct-'))
-    try {
-      // legacy opt-in marker no longer decides anything — pty is the default with or without it
-      writeFileSync(join(dir, 'codex-perplex.pty-host'), '')
-      expect(ptyHostEnabled(dir, 'codex-perplex')).toBe(true)
-      // the ready-gate viewport-source marker is a SEPARATE concern — it does not decide pty-hosting
-      writeFileSync(join(dir, 'codex-perplex.pty-readygate'), '')
-      expect(readyGatePtyFlipEnabled(dir, 'codex-perplex')).toBe(true)
-      expect(ptyHostEnabled(dir, 'codex-perplex')).toBe(true) // still hosted (default)
-      // only the explicit opt-out marker flips it back to tmux
-      writeFileSync(join(dir, 'codex-perplex.no-pty-host'), '')
-      expect(ptyHostEnabled(dir, 'codex-perplex')).toBe(false)
-    } finally {
-      rmSync(dir, { recursive: true, force: true })
-    }
-  })
-})

package/src/launch/readyGateModel.test.ts

@@ -1,72 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { logReadyGateCrossCheck, readyGatePtyFlipEnabled, readyGateViewport } from './readyGateModel.ts'
-
-// The Ф1 ready-gate source swap is DARK by default and falls back to capture-pane UNCONDITIONALLY,
-// so the flip can never make readiness worse than tmux today. These prove exactly that contract.
-const tmps: string[] = []
-const mkLogDir = (): string => {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-rgm-'))
-  tmps.push(d)
-  return d
-}
-afterEach(() => {
-  while (tmps.length) rmSync(tmps.pop()!, { recursive: true, force: true })
-})
-const FALLBACK = '<<capture-pane-fallback>>'
-
-describe('readyGatePtyFlipEnabled (per-peer flip flag, canary-first)', () => {
-  test('absent marker → off; present marker → on', () => {
-    const d = mkLogDir()
-    expect(readyGatePtyFlipEnabled(d, 'codex-x')).toBe(false)
-    writeFileSync(join(d, 'codex-x.pty-readygate'), '')
-    expect(readyGatePtyFlipEnabled(d, 'codex-x')).toBe(true)
-  })
-})
-
-describe('readyGateViewport (Ф1 viewport-source swap, tmux-fallback)', () => {
-  test('flag OFF → the capture-pane fallback VERBATIM (byte-identical to today, no model built)', async () => {
-    const d = mkLogDir()
-    expect(await readyGateViewport({ logDir: d, identity: 'codex-x', fallback: FALLBACK, cols: 80, rows: 24 })).toBe(FALLBACK)
-  })
-
-  test('flag ON + a pane-log → the MODEL viewport (source swapped), not the fallback', async () => {
-    const d = mkLogDir()
-    writeFileSync(join(d, 'codex-x.pty-readygate'), '')
-    writeFileSync(join(d, 'codex-x.log'), '\x1b[24;1H› ready prompt here') // render a codex '›' prompt row
-    const v = await readyGateViewport({ logDir: d, identity: 'codex-x', fallback: FALLBACK, cols: 80, rows: 24 })
-    expect(v).not.toBe(FALLBACK) // the source was swapped to the model
-    expect(v).toContain('› ready prompt here') // the model rendered the prompt the predicate keys on
-  })
-
-  test('flag ON but the pane-log is MISSING → fallback (never worse than tmux)', async () => {
-    const d = mkLogDir()
-    writeFileSync(join(d, 'codex-x.pty-readygate'), '')
-    expect(await readyGateViewport({ logDir: d, identity: 'codex-x', fallback: FALLBACK, cols: 80, rows: 24 })).toBe(FALLBACK)
-  })
-
-  test('flag ON but geometry is unknown (0x0) → fallback', async () => {
-    const d = mkLogDir()
-    writeFileSync(join(d, 'codex-x.pty-readygate'), '')
-    writeFileSync(join(d, 'codex-x.log'), '\x1b[24;1H› ready')
-    expect(await readyGateViewport({ logDir: d, identity: 'codex-x', fallback: FALLBACK, cols: 0, rows: 0 })).toBe(FALLBACK)
-  })
-})
-
-describe('logReadyGateCrossCheck (serving-path soak observability)', () => {
-  test('appends a record with diverged computed; agreement → false, mismatch → true', () => {
-    const d = mkLogDir()
-    logReadyGateCrossCheck(d, { identity: 'codex-x', modelReady: true, captureReady: false, geom: '220x50', nowISO: '2026-06-14T00:00:00Z' })
-    logReadyGateCrossCheck(d, { identity: 'codex-x', modelReady: true, captureReady: true, geom: '220x50', nowISO: '2026-06-14T00:00:05Z' })
-    const lines = readFileSync(join(d, 'readygate-flip.jsonl'), 'utf8').trim().split('\n').map(l => JSON.parse(l))
-    expect(lines[0].diverged).toBe(true) // model ahead of capture
-    expect(lines[0].modelReady).toBe(true)
-    expect(lines[0].captureReady).toBe(false)
-    expect(lines[1].diverged).toBe(false) // agreement
-  })
-  test('no event-log dir → no-op (never blocks the ready-gate)', () => {
-    expect(() => logReadyGateCrossCheck(undefined, { identity: 'x', modelReady: true, captureReady: true, geom: '1x1', nowISO: 't' })).not.toThrow()
-  })
-})

package/src/launch/sockdir.test.ts

@@ -1,74 +0,0 @@
-// Regression: launch() must `mkdir -p` the socket's parent dir before
-// `tmux new-session -S <sock>` — tmux does NOT create it and fails silently
-// ("session died immediately") when the IAPEER_SOCK_DIR override points at a
-// not-yet-created dir (prod sock=/tmp always exists; this bit a sandbox pilot).
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { dirname, join } from 'path'
-import { spawnSync } from 'child_process'
-import { launch } from './index.ts'
-import { notifierAdapter } from './adapters/notifier.ts'
-import type { LaunchConfig, LaunchSpec } from './types.ts'
-
-const dirs: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-sockdir-'))
-  dirs.push(d)
-  return d
-}
-afterEach(() => {
-  while (dirs.length) rmSync(dirs.pop()!, { recursive: true, force: true })
-})
-
-const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0
-
-describe('launch creates a missing socket dir', () => {
-  test.if(tmuxAvailable)('router launch into a NON-EXISTENT IAPEER_SOCK_DIR comes up (dir auto-created)', async () => {
-    const root = mkTmp()
-    const sockDir = join(root, 'does', 'not', 'exist', 'yet') // deep, absent
-    const sock = join(sockDir, 'tmux-iap-notifier-sockt.sock')
-    const bin = join(root, 'notifier-runtime')
-    writeFileSync(bin, '#!/bin/sh\nexec sleep 30\n', { mode: 0o755 })
-
-    const spec: LaunchSpec = {
-      personality: 'sockt',
-      runtime: 'notifier',
-      cwd: root,
-      identity: 'notifier-sockt',
-      socketPath: sock,
-      intelligence: 'absent',
-    }
-    const cfg: LaunchConfig = {
-      claudeBin: 'claude',
-      codexBin: 'codex',
-      notifierBin: bin,
-      sockDir,
-      bootDeadlineSecs: 1,
-      readyGateSecs: 1,
-      logDir: join(root, 'logs'),
-      alwaysOn: true,
-    }
-
-    // pty-supervisor hosting is the DEFAULT; this regression tests the legacy TMUX new-session sock-dir
-    // mkdir, so opt this peer OUT of pty with a .no-pty-host marker (else it is pty-hosted and the tmux
-    // mkdir never runs).
-    mkdirSync(cfg.logDir, { recursive: true })
-    writeFileSync(join(cfg.logDir, `${spec.identity}.no-pty-host`), '')
-    try {
-      // The regression assertion: before the fix the dir was NOT created and
-      // `tmux new-session -S <sock>` failed silently; now launch mkdir's it. (We assert
-      // dir creation, not the READY outcome — whether the session reaches READY depends
-      // on tmux + the test-runner env, which is orthogonal to this fix.)
-      await launch(spec, notifierAdapter, '', cfg)
-      expect(existsSync(sockDir)).toBe(true)
-    } finally {
-      spawnSync('tmux', ['-S', sock, 'kill-server'], { stdio: 'ignore' })
-    }
-  })
-
-  test('the fix is unconditional dirname(sock) creation (documents the parent)', () => {
-    expect(dirname('/a/b/c/tmux-iap-notifier-x.sock')).toBe('/a/b/c')
-  })
-})

package/src/lifecycle/eventlog.test.ts

@@ -1,114 +0,0 @@
-// eventlog — the daemon's durable, rotated lifecycle decision log. Tests the pure
-// logfmt formatter, the append path (into an explicit temp logDir — never the real
-// ~/.iapeer), and the size-rotation chain. No daemon, no tmux — pure FS.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import {
-  appendLifecycleEvent,
-  fmtValue,
-  formatEventLine,
-  lifecycleLogPath,
-} from './eventlog.ts'
-
-const TS = 1_749_470_400_000 // fixed epoch-ms → a stable ISO for golden lines
-const ISO = new Date(TS).toISOString()
-
-describe('fmtValue (logfmt escaping)', () => {
-  test('bare token stays bare', () => {
-    expect(fmtValue('reaped-idle')).toBe('reaped-idle')
-    expect(fmtValue('claude-boris')).toBe('claude-boris')
-    expect(fmtValue(42)).toBe('42')
-  })
-  test('empty string → ""', () => {
-    expect(fmtValue('')).toBe('""')
-  })
-  test('whitespace / = / " force quoting and escape', () => {
-    expect(fmtValue('session no longer live')).toBe('"session no longer live"')
-    expect(fmtValue('a=b')).toBe('"a=b"')
-    expect(fmtValue('say "hi"')).toBe('"say \\"hi\\""')
-    expect(fmtValue('back\\slash here')).toBe('"back\\\\slash here"')
-  })
-})
-
-describe('formatEventLine', () => {
-  test('ts is first; fields keep insertion order; undefined skipped', () => {
-    const line = formatEventLine(TS, {
-      ev: 'supervise',
-      identity: 'claude-boris',
-      action: 'reaped-gone',
-      reason: 'session no longer live',
-      ref: undefined, // dropped
-      outcome: 'fresh-next-msg',
-    })
-    expect(line).toBe(
-      `ts=${ISO} ev=supervise identity=claude-boris action=reaped-gone reason="session no longer live" outcome=fresh-next-msg`,
-    )
-  })
-  test('age field renders as a bare token', () => {
-    const line = formatEventLine(TS, { ev: 'supervise', identity: 'claude-x', action: 'reaped-idle', age: '4230s' })
-    expect(line).toBe(`ts=${ISO} ev=supervise identity=claude-x action=reaped-idle age=4230s`)
-  })
-})
-
-describe('appendLifecycleEvent', () => {
-  let dir: string
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), 'iapeer-eventlog-'))
-  })
-  afterEach(() => {
-    rmSync(dir, { recursive: true, force: true })
-  })
-
-  test('falsy logDir → no-op (a partial cfg never writes / never resolves a real path)', () => {
-    expect(() => appendLifecycleEvent(undefined, { ev: 'supervise', identity: 'x' }, { nowMs: TS })).not.toThrow()
-    expect(() => appendLifecycleEvent('', { ev: 'supervise', identity: 'x' }, { nowMs: TS })).not.toThrow()
-  })
-
-  test('writes one logfmt line per call, appended in order', () => {
-    appendLifecycleEvent(dir, { ev: 'wake', personality: 'boris', mode: 'fresh', cause: 'crash-or-self-close' }, { nowMs: TS })
-    appendLifecycleEvent(dir, { ev: 'supervise', identity: 'claude-doc', action: 'reaped-gone' }, { nowMs: TS + 1000 })
-    const body = readFileSync(lifecycleLogPath(dir), 'utf8')
-    const lines = body.trimEnd().split('\n')
-    expect(lines).toHaveLength(2)
-    expect(lines[0]).toBe(`ts=${ISO} ev=wake personality=boris mode=fresh cause=crash-or-self-close`)
-    expect(lines[1]).toContain('ev=supervise identity=claude-doc action=reaped-gone')
-  })
-
-  test('creates the log dir if absent', () => {
-    const nested = join(dir, 'logs', 'iapeer')
-    appendLifecycleEvent(nested, { ev: 'supervise', identity: 'x' }, { nowMs: TS })
-    expect(existsSync(lifecycleLogPath(nested))).toBe(true)
-  })
-
-  test('size rotation: base → .1, oldest dropped past keep', () => {
-    const env = { IAPEER_LIFECYCLE_LOG_MAX_BYTES: '120', IAPEER_LIFECYCLE_LOG_KEEP: '2' }
-    const path = lifecycleLogPath(dir)
-    for (let i = 0; i < 6; i++) {
-      appendLifecycleEvent(dir, { ev: 'supervise', identity: `claude-peer${i}`, action: 'reaped-gone', n: i }, { env, nowMs: TS + i })
-    }
-    expect(existsSync(path)).toBe(true)
-    expect(existsSync(`${path}.1`)).toBe(true)
-    expect(existsSync(`${path}.2`)).toBe(true)
-    expect(existsSync(`${path}.3`)).toBe(false) // keep=2 → never a .3
-    expect(statSync(path).size).toBeLessThanOrEqual(200)
-    expect(readFileSync(path, 'utf8')).toContain('claude-peer5') // newest in the live base file
-  })
-
-  test('rotation preserves chronological order across files (.N oldest, base newest)', () => {
-    const env = { IAPEER_LIFECYCLE_LOG_MAX_BYTES: '90', IAPEER_LIFECYCLE_LOG_KEEP: '3' }
-    const path = lifecycleLogPath(dir)
-    for (let i = 0; i < 4; i++) {
-      appendLifecycleEvent(dir, { ev: 'supervise', identity: `claude-p${i}` }, { env, nowMs: TS + i })
-    }
-    const ordered = ['.3', '.2', '.1', '']
-      .map(suf => (existsSync(path + suf) ? readFileSync(path + suf, 'utf8') : ''))
-      .join('')
-    const seen = [...ordered.matchAll(/identity=claude-p(\d)/g)].map(m => Number(m[1]))
-    expect(seen).toEqual([...seen].sort((a, b) => a - b))
-    expect(seen[seen.length - 1]).toBe(3) // newest line is p3, in the base file
-  })
-})