@agfpd/iapeer 0.2.77 → 0.2.78

package/src/shadow/install.test.ts

@@ -1,153 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
-import { spawnSync } from 'node:child_process'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { isFoundationOwnedPlist } from '../launch/launchd.ts'
-import {
-  SHADOW_PERSONALITY,
-  SHADOW_PLIST_LABEL,
-  buildShadowPlistSpec,
-  cycleShadowJob,
-  installShadowJob,
-  installShadowPlist,
-  shadowPlistPath,
-  uninstallShadowJob,
-} from './install.ts'
-
-// Hermetic: every plist write lands under IAPEER_LAUNCHAGENTS_DIR / IAPEER_ROOT overrides, and
-// the suite runs with IAPEER_TEST_SANDBOX=1 (process.env) so the launchctl-touching paths
-// (installShadowJob / cycleShadowJob / uninstallShadowJob) fail-CLOSED to skipped-sandbox — they
-// NEVER load/unload a real launchd job. No tmux, no @xterm (install.ts is pure plumbing).
-
-const tmpDirs: string[] = []
-function mkEnv(extra: Record<string, string> = {}): NodeJS.ProcessEnv {
-  const root = mkdtempSync(join(tmpdir(), 'iapeer-shadow-install-'))
-  tmpDirs.push(root)
-  return {
-    IAPEER_LAUNCHAGENTS_DIR: join(root, 'LaunchAgents'),
-    IAPEER_ROOT: join(root, 'iapeer'),
-    HOME: root,
-    PATH: '/usr/bin:/bin',
-    ...extra,
-  } as NodeJS.ProcessEnv
-}
-afterEach(() => {
-  while (tmpDirs.length) rmSync(tmpDirs.pop()!, { recursive: true, force: true })
-})
-const plutilLint = (path: string): boolean => spawnSync('plutil', ['-lint', path], { encoding: 'utf8' }).status === 0
-
-describe('buildShadowPlistSpec', () => {
-  test('label is com.iapeer.shadow-fidelity and runs the INSTALLED `iapeer shadow`', () => {
-    const spec = buildShadowPlistSpec({ HOME: '/Users/x' } as NodeJS.ProcessEnv)
-    expect(spec.label).toBe(SHADOW_PLIST_LABEL)
-    expect(SHADOW_PLIST_LABEL).toBe('com.iapeer.shadow-fidelity')
-    expect(spec.programArguments).toEqual(['/Users/x/.local/bin/iapeer', 'shadow'])
-  })
-  test('launchd-minimal PATH includes /opt/homebrew/bin (tmux lives there — the observer shells read-only tmux)', () => {
-    expect(buildShadowPlistSpec({ HOME: '/Users/x' } as NodeJS.ProcessEnv).environment.PATH).toContain('/opt/homebrew/bin')
-  })
-  test('stdout/stderr land under ~/.iapeer/logs/iapeer', () => {
-    const spec = buildShadowPlistSpec(mkEnv())
-    expect(spec.stdoutPath).toContain(join('logs', 'iapeer', 'shadow-fidelity.launchd-stdout.log'))
-    expect(spec.stderrPath).toContain(join('logs', 'iapeer', 'shadow-fidelity.launchd-stderr.log'))
-  })
-})
-
-describe('installShadowPlist', () => {
-  test('writes a valid, foundation-owned (sentinel) always-on plist under the override dir', () => {
-    const env = mkEnv()
-    const r = installShadowPlist(env)
-    expect(r.path).toBe(shadowPlistPath(env))
-    expect(r.changed).toBe(true)
-    expect(existsSync(r.path)).toBe(true)
-    expect(isFoundationOwnedPlist(r.path)).toBe(true) // carries the ownership sentinel
-    expect(plutilLint(r.path)).toBe(true)
-    const xml = readFileSync(r.path, 'utf8')
-    expect(xml).toContain(`<string>${SHADOW_PLIST_LABEL}</string>`)
-    expect(xml).toContain('<string>shadow</string>')
-    expect(xml).toContain('<key>RunAtLoad</key>')
-    expect(xml).toContain('<key>KeepAlive</key>')
-  })
-
-  test('idempotent by content: an unchanged re-install does NOT rewrite (changed:false, mtime stable); a changed PATH DOES', () => {
-    const env = mkEnv()
-    const first = installShadowPlist(env)
-    expect(first.changed).toBe(true)
-    const mtime1 = statSync(first.path).mtimeMs
-    const second = installShadowPlist(env)
-    expect(second.changed).toBe(false)
-    expect(statSync(second.path).mtimeMs).toBe(mtime1) // file untouched (no BTM spam)
-    // a different rendered plist (PATH override) rewrites
-    const third = installShadowPlist(mkEnv({ IAPEER_SHADOW_PATH: '/opt/homebrew/bin:/usr/bin:/bin', IAPEER_LAUNCHAGENTS_DIR: env.IAPEER_LAUNCHAGENTS_DIR!, IAPEER_ROOT: env.IAPEER_ROOT!, HOME: env.HOME! }))
-    expect(third.changed).toBe(true)
-  })
-
-  test('collision guard: REFUSES to overwrite a foreign (no-sentinel) plist at the label', () => {
-    const env = mkEnv()
-    const laDir = env.IAPEER_LAUNCHAGENTS_DIR!
-    mkdirSync(laDir, { recursive: true })
-    const path = shadowPlistPath(env)
-    const foreign = '<?xml version="1.0"?>\n<plist><dict><key>Label</key><string>com.iapeer.shadow-fidelity</string></dict></plist>\n'
-    writeFileSync(path, foreign)
-    expect(() => installShadowPlist(env)).toThrow(/foundation-managed|refus/i)
-    expect(readFileSync(path, 'utf8')).toBe(foreign) // untouched — guard fires before any write
-  })
-})
-
-describe('installShadowJob (sandbox fail-closed)', () => {
-  test('writes the plist FILE but NEVER touches launchctl under IAPEER_TEST_SANDBOX → skipped-sandbox', () => {
-    const env = mkEnv()
-    const r = installShadowJob(env)
-    expect(r.action).toBe('skipped-sandbox')
-    expect(r.path).toBe(shadowPlistPath(env))
-    expect(r.changed).toBe(true)
-    expect(existsSync(r.path)).toBe(true) // file written to the override dir
-    expect(isFoundationOwnedPlist(r.path)).toBe(true)
-  })
-})
-
-describe('cycleShadowJob (deploy re-cycle hook)', () => {
-  test('returns null when no plist exists (nothing to recycle)', () => {
-    expect(cycleShadowJob(mkEnv())).toBeNull()
-  })
-  test('a written foundation plist recycles to skipped-sandbox under the test flag (never a real launchctl cycle)', () => {
-    const env = mkEnv()
-    installShadowPlist(env)
-    expect(cycleShadowJob(env)?.state).toBe('skipped-sandbox')
-  })
-  test('a foreign plist at the label is NOT recycled (ownership guard) → null', () => {
-    const env = mkEnv()
-    mkdirSync(env.IAPEER_LAUNCHAGENTS_DIR!, { recursive: true })
-    writeFileSync(shadowPlistPath(env), '<?xml version="1.0"?>\n<plist><dict/></plist>\n')
-    expect(cycleShadowJob(env)).toBeNull()
-  })
-})
-
-describe('uninstallShadowJob', () => {
-  test('absent plist → absent (no-op)', () => {
-    expect(uninstallShadowJob(mkEnv()).action).toBe('absent')
-  })
-  test('foundation plist under sandbox → skipped-sandbox, plist left in place (no real bootout)', () => {
-    const env = mkEnv()
-    installShadowPlist(env)
-    const r = uninstallShadowJob(env)
-    expect(r.action).toBe('skipped-sandbox')
-    expect(existsSync(shadowPlistPath(env))).toBe(true)
-  })
-  test('foreign plist → refused-foreign, untouched', () => {
-    const env = mkEnv()
-    mkdirSync(env.IAPEER_LAUNCHAGENTS_DIR!, { recursive: true })
-    const path = shadowPlistPath(env)
-    writeFileSync(path, '<?xml version="1.0"?>\n<plist><dict/></plist>\n')
-    expect(uninstallShadowJob(env).action).toBe('refused-foreign')
-    expect(existsSync(path)).toBe(true)
-  })
-})
-
-describe('exports wire to the running job', () => {
-  test('SHADOW_PERSONALITY/LABEL match the live burn-in job naming', () => {
-    expect(SHADOW_PERSONALITY).toBe('shadow-fidelity')
-    expect(SHADOW_PLIST_LABEL).toBe('com.iapeer.shadow-fidelity')
-  })
-})

package/src/shadow/shadow.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { Terminal } from '@xterm/headless'
-import { composerOccupancyFromModel, modelToPlainText } from './index.ts'
-
-// The observer's pty-side verdicts are pure functions of the @xterm model — hermetic, no tmux.
-// These mirror the verdicts validated 0-divergence vs the prod tmux verdicts in the migration
-// fidelity shadows (occupancy: getCell dim/ghost; ready-gate: isInputReady on plain text).
-const build = (frame: string, cols = 80, rows = 24): Promise<Terminal> =>
-  new Promise(res => { const t = new Terminal({ cols, rows, allowProposedApi: true, scrollback: 200 }); t.write(frame, () => res(t)) })
-
-describe('composerOccupancyFromModel (pty occupancy verdict)', () => {
-  test('human non-dim text after the prompt glyph → TRUE', async () => {
-    const t = await build(`\x1b[24;1H❯ the quick brown fox`)
-    expect(composerOccupancyFromModel(t, 80, 24, 'claude')).toBe(true)
-  })
-  test('dim/ghost placeholder after the glyph → FALSE (the critical discriminator)', async () => {
-    const t = await build(`\x1b[24;1H❯ \x1b[2m\x1b[38;5;246mTry "fix typecheck errors"\x1b[0m`)
-    expect(composerOccupancyFromModel(t, 80, 24, 'claude')).toBe(false)
-  })
-  test('empty composer (glyph alone) → FALSE', async () => {
-    const t = await build(`\x1b[24;1H❯ `)
-    expect(composerOccupancyFromModel(t, 80, 24, 'claude')).toBe(false)
-  })
-  test('codex glyph › with human text → TRUE', async () => {
-    const t = await build(`\x1b[24;1H› reviewer note`)
-    expect(composerOccupancyFromModel(t, 80, 24, 'codex')).toBe(true)
-  })
-  test('no prompt glyph at all → FALSE', async () => {
-    const t = await build(`\x1b[24;1Hjust some output line`)
-    expect(composerOccupancyFromModel(t, 80, 24, 'claude')).toBe(false)
-  })
-})
-
-describe('modelToPlainText (feeds isInputReady)', () => {
-  test('renders the viewport as plain text (no SGR), trailing-trimmed', async () => {
-    const t = await build(`\x1b[1;1Hhello\x1b[2;1H\x1b[1mbold\x1b[0m world`)
-    const plain = modelToPlainText(t, 80, 24)
-    expect(plain.split('\n')[0]).toBe('hello')
-    expect(plain).toContain('bold world')
-    expect(plain).not.toContain('\x1b')
-  })
-})

package/src/status/status.test.ts

@@ -1,208 +0,0 @@
-// Memory slot — the DECLARATIVE provider slot (docs/Слот памяти — контракт
-// memory provider.md): the core only READS the root declaration; absent /
-// unreadable / invalid → EMPTY slot (bare core, valid state, never an error).
-// Plus the host-status assembly + rendering (memory: <provider> | none).
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import {
-  formatHostStatus,
-  heartbeatAgeSecs,
-  hostStatus,
-  memoryProviderPath,
-  readMemoryProvider,
-  type HostStatus,
-  type MemoryProvider,
-} from './index.ts'
-
-const dirs: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-slot-'))
-  dirs.push(d)
-  return d
-}
-afterEach(() => {
-  while (dirs.length) rmSync(dirs.pop()!, { recursive: true, force: true })
-})
-
-function envFor(root: string): NodeJS.ProcessEnv {
-  return { IAPEER_ROOT: root } as NodeJS.ProcessEnv
-}
-
-const VALID = {
-  provider: 'iapeer-memory',
-  package: '@agfpd/iapeer-memory',
-  version: '0.1.0',
-  registeredAt: '2026-06-10T00:00:00Z',
-}
-
-describe('readMemoryProvider (slot declaration, fail-open)', () => {
-  test('absent file → null (EMPTY slot — valid bare state)', () => {
-    expect(readMemoryProvider(envFor(mkTmp()))).toBeNull()
-  })
-
-  test('valid declaration → parsed provider; heartbeat optional', () => {
-    const root = mkTmp()
-    writeFileSync(memoryProviderPath(envFor(root)), JSON.stringify({ ...VALID, heartbeat: '/tmp/hb' }))
-    const p = readMemoryProvider(envFor(root))
-    expect(p).toMatchObject({ ...VALID, heartbeat: '/tmp/hb' })
-    // without heartbeat — field absent, not empty-string
-    writeFileSync(memoryProviderPath(envFor(root)), JSON.stringify(VALID))
-    expect(readMemoryProvider(envFor(root))?.heartbeat).toBeUndefined()
-  })
-
-  test('garbage / wrong shape / missing required fields → null, NEVER throws', () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    for (const bad of ['NOT JSON {{{', '[]', '{}', JSON.stringify({ provider: 'x' }), JSON.stringify({ ...VALID, version: 42 })]) {
-      writeFileSync(memoryProviderPath(env), bad)
-      expect(readMemoryProvider(env)).toBeNull()
-    }
-  })
-
-  test('LEGACY v1.1 plugin block (any shape) → ignored as unknown noise; the declaration itself stays valid (form removed 11.06, ADR-017)', () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    for (const legacy of [
-      { name: 'iapeer-memory', marketplace: 'agfpd', marketplaceRef: 'agfpd/agfpd-marketplace' }, // a complete v1.1 block
-      { name: 'x', marketplace: 'agfpd' },
-      'iapeer-memory',
-      ['x'],
-    ]) {
-      writeFileSync(memoryProviderPath(env), JSON.stringify({ ...VALID, plugin: legacy }))
-      const p = readMemoryProvider(env)
-      expect(p).not.toBeNull()
-      expect((p as Record<string, unknown> | null)?.plugin).toBeUndefined() // not parsed at all
-    }
-  })
-
-  test('v1.2 provision/unprovision blocks: parsed when valid; relative command or bad args = absent (fail-open)', () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    const provision = { command: '/usr/local/bin/iapeer-memory', args: ['provision-peer', '--cwd', '{cwd}'] }
-    const unprovision = { command: '/usr/local/bin/iapeer-memory', args: ['unprovision-peer'] }
-    writeFileSync(memoryProviderPath(env), JSON.stringify({ ...VALID, provision, unprovision }))
-    const p = readMemoryProvider(env)
-    expect(p?.provision).toEqual(provision)
-    expect(p?.unprovision).toEqual(unprovision)
-    // empty args array is VALID (command alone)
-    writeFileSync(memoryProviderPath(env), JSON.stringify({ ...VALID, provision: { command: '/x/y', args: [] } }))
-    expect(readMemoryProvider(env)?.provision).toEqual({ command: '/x/y', args: [] })
-    // invalid shapes → block absent, declaration itself stays valid
-    for (const bad of [
-      { command: 'iapeer-memory', args: [] }, // RELATIVE command (launchd minimal PATH) — contract-invalid
-      { command: '/x/y' }, // args missing
-      { command: '/x/y', args: ['ok', 42] }, // non-string arg
-      { args: ['provision-peer'] }, // command missing
-      'provision-me', // not an object
-    ]) {
-      writeFileSync(memoryProviderPath(env), JSON.stringify({ ...VALID, provision: bad }))
-      const r = readMemoryProvider(env)
-      expect(r).not.toBeNull()
-      expect(r?.provision).toBeUndefined()
-    }
-  })
-})
-
-describe('heartbeatAgeSecs', () => {
-  test('no heartbeat declared → null; declared but absent file → null; present → age', () => {
-    const root = mkTmp()
-    expect(heartbeatAgeSecs({ ...VALID } as MemoryProvider)).toBeNull()
-    const hb = join(root, 'memoryd.heartbeat')
-    expect(heartbeatAgeSecs({ ...VALID, heartbeat: hb } as MemoryProvider)).toBeNull() // not running
-    writeFileSync(hb, '')
-    const old = (Date.now() - 45_000) / 1000
-    utimesSync(hb, old, old)
-    const age = heartbeatAgeSecs({ ...VALID, heartbeat: hb } as MemoryProvider)
-    expect(age).toBeGreaterThanOrEqual(44)
-    expect(age).toBeLessThanOrEqual(60)
-  })
-})
-
-describe('hostStatus + formatHostStatus', () => {
-  test('empty slot → memory: none; daemon health from the injected probe', async () => {
-    const root = mkTmp()
-    const s = await hostStatus({ env: envFor(root), probe: async () => true, fdaProbe: () => null })
-    expect(s.daemon.healthy).toBe(true)
-    expect(s.memory.provider).toBeNull()
-    expect(formatHostStatus(s)).toContain('memory: none')
-  })
-
-  test('occupied slot + fresh heartbeat → provider line with age', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    const hb = join(root, 'memoryd.heartbeat')
-    writeFileSync(hb, '')
-    writeFileSync(memoryProviderPath(env), JSON.stringify({ ...VALID, heartbeat: hb }))
-    const s = await hostStatus({ env, probe: async () => true, fdaProbe: () => null })
-    expect(formatHostStatus(s)).toMatch(/memory: iapeer-memory 0\.1\.0 \(heartbeat \d+s ago\)/)
-  })
-
-  test('occupied slot, heartbeat declared but file ABSENT → "daemon not running" (graceful-shutdown semantics)', () => {
-    const s: HostStatus = {
-      version: '0.0.0',
-      daemon: { healthy: false, url: null, sock: null },
-      memory: {
-        provider: { ...VALID, heartbeat: '/nope/hb' } as MemoryProvider,
-        heartbeatAgeSecs: null,
-      },
-      fda: null,
-    }
-    const text = formatHostStatus(s)
-    expect(text).toContain('memory: iapeer-memory 0.1.0 (daemon not running — no heartbeat file)')
-    expect(text).toContain('daemon: NOT healthy')
-  })
-
-  test('discovery file addresses surface in the daemon line', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    const stateDir = join(root, 'state', 'iapeer')
-    mkdirSync(stateDir, { recursive: true })
-    writeFileSync(join(stateDir, 'router.json'), JSON.stringify({ sock: '/x/router.sock', tcp: 'http://127.0.0.1:8765/mcp' }))
-    const s = await hostStatus({ env, probe: async () => true, fdaProbe: () => null })
-    const text = formatHostStatus(s)
-    expect(text).toContain('@ http://127.0.0.1:8765/mcp')
-    expect(text).toContain('+ /x/router.sock')
-  })
-})
-
-describe('FDA detection (iapeer status — fresh-host observability)', () => {
-  function base(fda: boolean | null): HostStatus {
-    return {
-      version: '0.0.0',
-      daemon: { healthy: true, url: null, sock: null },
-      memory: { provider: null, heartbeatAgeSecs: null },
-      fda,
-    }
-  }
-
-  test('granted → terse OK line, no instruction', () => {
-    const text = formatHostStatus(base(true))
-    expect(text).toContain('fda: granted')
-    expect(text).not.toContain('NOT granted')
-    expect(text).not.toContain('Full Disk Access')
-  })
-
-  test('NOT granted → actionable hint with the binary path', () => {
-    const text = formatHostStatus(base(false))
-    expect(text).toContain('fda: NOT granted')
-    expect(text).toContain('Full Disk Access')
-    expect(text).toMatch(/iapeer$|iapeer\n/m) // the grant path ends at the binary
-  })
-
-  test('undeterminable → explicit unknown, never a false claim', () => {
-    const text = formatHostStatus(base(null))
-    expect(text).toContain('fda: unknown')
-    expect(text).not.toContain('NOT granted')
-    expect(text).not.toContain('granted\n') // not the bare "granted" either
-  })
-
-  test('hostStatus threads the injected fdaProbe verbatim', async () => {
-    const root = mkTmp()
-    const s = await hostStatus({ env: envFor(root), probe: async () => true, fdaProbe: () => false })
-    expect(s.fda).toBe(false)
-    expect(formatHostStatus(s)).toContain('fda: NOT granted')
-  })
-})

package/src/storage/peers-home.test.ts

@@ -1,34 +0,0 @@
-// peersHomeDir / defaultPeerCwd + ensureGlobalIapScaffold creating peers/ — the
-// foundation-owned default home for `iapeer create`.
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, rmSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { defaultPeerCwd, ensureGlobalIapScaffold, peersHomeDir } from './index.ts'
-
-const dirs: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-ph-'))
-  dirs.push(d)
-  return d
-}
-afterEach(() => {
-  while (dirs.length) rmSync(dirs.pop()!, { recursive: true, force: true })
-})
-
-describe('peers home', () => {
-  test('peersHomeDir / defaultPeerCwd resolve under IAPEER_ROOT', () => {
-    const root = mkTmp()
-    const env = { IAPEER_ROOT: join(root, 'iapeer'), HOME: root } as NodeJS.ProcessEnv
-    expect(peersHomeDir({ env })).toBe(join(root, 'iapeer', 'peers'))
-    expect(defaultPeerCwd('worker', { env })).toBe(join(root, 'iapeer', 'peers', 'worker'))
-  })
-
-  test('ensureGlobalIapScaffold creates ~/.iapeer/peers/', () => {
-    const root = mkTmp()
-    const env = { IAPEER_ROOT: join(root, 'iapeer'), HOME: root } as NodeJS.ProcessEnv
-    ensureGlobalIapScaffold({ env })
-    expect(existsSync(peersHomeDir({ env }))).toBe(true)
-  })
-})

package/src/storage/rotatelog.test.ts

@@ -1,44 +0,0 @@
-// rotatelog — the generic rotated-logfmt-append primitive (promoted from
-// lifecycle/eventlog.ts when the daemon's delivery.log became the second
-// producer). The logfmt formatting (fmtValue/formatEventLine) is pinned in
-// lifecycle/eventlog.test.ts (its historical home, re-exported); these tests
-// cover what is NEW at this layer: the path-parameterized append + rotation.
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { appendRotatedEvent } from './rotatelog.ts'
-
-const dirs: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-rotatelog-'))
-  dirs.push(d)
-  return d
-}
-afterEach(() => {
-  while (dirs.length) rmSync(dirs.pop()!, { recursive: true, force: true })
-})
-
-describe('appendRotatedEvent', () => {
-  test('creates the parent dir and appends one ts-stamped logfmt line', () => {
-    const path = join(mkTmp(), 'deep', 'nested', 'some.log')
-    appendRotatedEvent(path, { ev: 'delivery', ok: 'true', note: 'two words' }, { nowMs: 1750000000000 })
-    const text = readFileSync(path, 'utf8')
-    expect(text).toBe('ts=2025-06-15T15:06:40.000Z ev=delivery ok=true note="two words"\n')
-  })
-
-  test('rotates base → .1 at maxBytes and drops beyond keep', () => {
-    const path = join(mkTmp(), 'r.log')
-    const line = { ev: 'x', pad: 'a'.repeat(50) } // ~65 bytes/line
-    // maxBytes 100 → every second append rotates; keep 1 → no .2 ever exists.
-    for (let i = 0; i < 6; i++) appendRotatedEvent(path, line, { maxBytes: 100, keep: 1 })
-    expect(existsSync(path)).toBe(true)
-    expect(existsSync(`${path}.1`)).toBe(true)
-    expect(existsSync(`${path}.2`)).toBe(false)
-  })
-
-  test('never throws on an unwritable path (best-effort observability)', () => {
-    expect(() => appendRotatedEvent('/dev/null/impossible/x.log', { ev: 'x' })).not.toThrow()
-  })
-})

package/src/storage/storage.test.ts

@@ -1,65 +0,0 @@
-// readLaunchEnv — the per-peer per-runtime launch.env parser (Ф-A #5, zone
-// Хранение / Рантайм-адаптеры). Pure FS parser, no tmux: PEER_START_ARGS
-// word-splits (faithful to the legacy unquoted ${PEER_START_ARGS} expansion),
-// other KEY=VALUE lines become child env, quotes are stripped, comments/blanks
-// are ignored, and a missing file → empty.
-
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { peerLaunchEnvPath, readLaunchEnv } from './index.ts'
-
-let cwd: string
-beforeEach(() => {
-  cwd = mkdtempSync(join(tmpdir(), 'iapeer-launchenv-'))
-})
-afterEach(() => {
-  rmSync(cwd, { recursive: true, force: true })
-})
-
-function writeLaunchEnv(runtime: string, body: string): void {
-  const p = peerLaunchEnvPath(cwd, runtime)
-  mkdirSync(join(p, '..'), { recursive: true })
-  writeFileSync(p, body)
-}
-
-describe('readLaunchEnv', () => {
-  test('missing file → empty (no flags, no env)', () => {
-    expect(readLaunchEnv(cwd, 'claude')).toEqual({ startArgs: [], env: {} })
-  })
-
-  test('PEER_START_ARGS word-splits on whitespace; surrounding quotes stripped', () => {
-    writeLaunchEnv('claude', 'PEER_START_ARGS="--dangerously-load-development-channels --foo bar"\n')
-    expect(readLaunchEnv(cwd, 'claude').startArgs).toEqual([
-      '--dangerously-load-development-channels',
-      '--foo',
-      'bar',
-    ])
-  })
-
-  test('single arg, no quotes', () => {
-    writeLaunchEnv('codex', 'PEER_START_ARGS=--no-alt-screen\n')
-    expect(readLaunchEnv(cwd, 'codex').startArgs).toEqual(['--no-alt-screen'])
-  })
-
-  test('other KEY=VALUE lines become child env; PEER_START_ARGS is consumed (not in env)', () => {
-    writeLaunchEnv('claude', '# a comment\nexport FOO=bar\nBAZ="q u x"\nPEER_START_ARGS="--x"\n\n')
-    const { startArgs, env } = readLaunchEnv(cwd, 'claude')
-    expect(startArgs).toEqual(['--x'])
-    expect(env).toEqual({ FOO: 'bar', BAZ: 'q u x' })
-    expect(env.PEER_START_ARGS).toBeUndefined()
-  })
-
-  test('blank lines, comments, and non-assignment lines are ignored', () => {
-    writeLaunchEnv('claude', '\n  # comment\nnot an assignment line\nKEY=value\n')
-    expect(readLaunchEnv(cwd, 'claude').env).toEqual({ KEY: 'value' })
-  })
-
-  test('empty PEER_START_ARGS → no args', () => {
-    writeLaunchEnv('claude', 'PEER_START_ARGS=""\nFOO=bar\n')
-    const { startArgs, env } = readLaunchEnv(cwd, 'claude')
-    expect(startArgs).toEqual([])
-    expect(env).toEqual({ FOO: 'bar' })
-  })
-})

package/src/supervisor/attached-marker.test.ts

@@ -1,84 +0,0 @@
-// Spawn-flip cutover Block 2, Ф0b-3 slice 3c-1 — the supervisor `.attached` marker (the gate signal
-// `hasAttachedSupervisorClient` reads to hold hosted delivery ONLY for a real attached human).
-// boris's three faces: (1) present ⟺ clients.size>0; (2) ALL detach paths incl. ABNORMAL (abrupt
-// terminate → error/close), not just a clean Ctrl-]; (3) CRASH-ROBUSTNESS — a crashed predecessor
-// skips shutdown-cleanup, so a stale marker must be cleared on daemon START. Real detached daemon over
-// a real unix socket (tick runtime — no codex needed); the marker is read CROSS-PROCESS, as in prod.
-import { afterEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { frame, FRAME_RESIZE, sizePayload } from './protocol.ts'
-import { killSession, sessionAlive, sockPath, startSupervisorDaemon } from './index.ts'
-import { attachedPath } from './paths.ts'
-
-const [maj, min, pat] = (Bun.version || '0.0.0').split('.').map(Number) as [number, number, number]
-const bunPty = maj > 1 || (maj === 1 && (min > 3 || (min === 3 && pat >= 5)))
-const d = bunPty ? describe : describe.skip
-
-const sleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms))
-async function waitFor(pred: () => boolean, timeoutMs = 5000, step = 40): Promise<boolean> {
-  const end = Date.now() + timeoutMs
-  while (Date.now() < end) { if (pred()) return true; await sleep(step) }
-  return false
-}
-
-interface Client { end(): void; terminate(): void }
-async function attach(runDir: string, session: string): Promise<Client> {
-  const sock = await Bun.connect({
-    unix: sockPath(runDir, session),
-    socket: { open(s) { s.write(frame(FRAME_RESIZE, sizePayload(80, 24))) }, data() { /* */ } },
-  })
-  return {
-    end: () => { try { sock.end() } catch { /* */ } },
-    terminate: () => { try { sock.terminate() } catch { /* */ } },
-  }
-}
-
-const dirs: string[] = []
-const mkRunDir = (): string => { const d2 = mkdtempSync(join(tmpdir(), 'iapeer-attmark-')); dirs.push(d2); return d2 }
-afterEach(() => { for (const d2 of dirs.splice(0)) rmSync(d2, { recursive: true, force: true }) })
-
-d('supervisor .attached marker (the hosted occupancy gate signal)', () => {
-  test('present ⟺ clients.size>0 across multiple clients (no stuck "attached" on partial detach)', async () => {
-    const runDir = mkRunDir(), session = 'mk'
-    startSupervisorDaemon({ session, runtime: 'tick', runDir })
-    expect(await waitFor(() => sessionAlive(runDir, session))).toBe(true)
-    const marker = attachedPath(runDir, session)
-    expect(existsSync(marker)).toBe(false) // no client yet → absent
-    const c1 = await attach(runDir, session)
-    expect(await waitFor(() => existsSync(marker))).toBe(true) // ≥1 attached → present
-    const c2 = await attach(runDir, session)
-    await sleep(150)
-    expect(existsSync(marker)).toBe(true) // 2 attached → still present
-    c1.end()
-    await sleep(250)
-    expect(existsSync(marker)).toBe(true) // 1 still attached → NOT stuck-absent, NOT removed early
-    c2.end()
-    expect(await waitFor(() => !existsSync(marker))).toBe(true) // 0 attached → absent
-    killSession(runDir, session)
-  })
-
-  test('ABNORMAL detach (abrupt terminate, not a clean Ctrl-]) → marker still removed', async () => {
-    const runDir = mkRunDir(), session = 'ab'
-    startSupervisorDaemon({ session, runtime: 'tick', runDir })
-    expect(await waitFor(() => sessionAlive(runDir, session))).toBe(true)
-    const marker = attachedPath(runDir, session)
-    const c = await attach(runDir, session)
-    expect(await waitFor(() => existsSync(marker))).toBe(true)
-    c.terminate() // abrupt RST — daemon sees error/close, NOT a graceful protocol detach
-    expect(await waitFor(() => !existsSync(marker))).toBe(true) // the error/close path ALSO syncs the marker
-    killSession(runDir, session)
-  })
-
-  test('CRASH-ROBUSTNESS: a stale marker is cleared on daemon START (crash skips shutdown-cleanup)', async () => {
-    const runDir = mkRunDir(), session = 'cr'
-    const marker = attachedPath(runDir, session)
-    writeFileSync(marker, '') // a crashed predecessor left this present, with no live client
-    expect(existsSync(marker)).toBe(true)
-    startSupervisorDaemon({ session, runtime: 'tick', runDir }) // fresh daemon = 0 clients
-    expect(await waitFor(() => sessionAlive(runDir, session))).toBe(true)
-    expect(await waitFor(() => !existsSync(marker))).toBe(true) // start-cleanup removed the stale lie
-    killSession(runDir, session)
-  })
-})