@agfpd/iapeer 0.1.2 → 0.2.1

package/src/lifecycle/lifecycle.test.ts

@@ -1,25 +1,32 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import {
   attachPeer,
-  clearNewMark,
+  clearNewEager,
   clearStopped,
   composeFirstMessage,
+  countRecentDeaths,
   folderLaunch,
-  hasNewMark,
+  hasIdleReaped,
+  hasNewEager,
   isLaunchdManaged,
   isStopped,
   lastActiveRuntime,
   loadLifecycleConfig,
+  readDeaths,
+  readTopic,
+  recordDeath,
   resolveWakeMode,
   resolveWakeRuntime,
-  setNewMark,
+  setIdleReaped,
+  setNewEager,
   setStopped,
   superviseTick,
   wakeOrSpawn,
   withWakeLock,
+  writeTopic,
   type LifecycleConfig,
 } from './index.ts'
 import { upsertPeer, type PeerRecord } from '../registry/index.ts'
@@ -72,10 +79,12 @@ describe('resolveWakeRuntime (H5)', () => {
 // ─────────────────────────────────────────────────────────────────────────────
 
 describe('isLaunchdManaged (H4 detector, live read-only)', () => {
-  test('a launchd-managed peer (boris has com.iapeer.boris.plist) → true', () => {
-    // The live host has com.iapeer.boris.plist — the daemon must treat boris as
-    // READ-ONLY (never wake/reap). This proves the detector fires on the fleet.
-    expect(isLaunchdManaged('boris')).toBe(true)
+  test('a launchd-managed peer (timer has com.iapeer.timer.plist) → true', () => {
+    // Post foundation-migration the always-on INFRA peers (timer/watcher/arthur) keep
+    // their com.iapeer.<p>.plist; the daemon must treat them READ-ONLY (never
+    // wake/reap). This proves the detector fires on the live fleet. (boris and the
+    // agent peers became warm-on-demand — plist relocated — so they are NOT managed.)
+    expect(isLaunchdManaged('timer')).toBe(true)
   })
 
   test('a made-up daemon-owned name (no plist) → false', () => {
@@ -167,6 +176,7 @@ describe('superviseTick H4 guard', () => {
       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,
@@ -195,11 +205,17 @@ describe('superviseTick H4 guard', () => {
   })
 
   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(cfg(), { env: env(), nowMs: Date.now() })
+    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')
   })
 
   test('empty state dir → no outcomes', () => {
@@ -338,54 +354,119 @@ describe('C2 initial_prompt (composeFirstMessage)', () => {
 })
 
 // ─────────────────────────────────────────────────────────────────────────────
-// C3a + C4a — resolveWakeMode (resume-vs-fresh; the contract-divergence fix)
+// resolveWakeMode — TARGET redesign (daemon decides fresh-vs-resume by DEATH CAUSE
+// = .idle-reaped marker, plus peer-type/topic; NO agent-dropped fresh mark).
 // ─────────────────────────────────────────────────────────────────────────────
 
-describe('resolveWakeMode (C3a default-resume + C4a /new-mark)', () => {
+/** A temp cwd with a peer-profile; interfaces.telegram present → human-conversational. */
+function profileCwd(human: boolean): 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 } } } : {}),
+    }),
+  )
+  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) => {
+    const c = profileCwd(human)
+    cwds.push(c)
+    return c
+  }
   const hasTranscript = () => ({ ok: true, ref: 'uuid-1' })
   const noTranscript = () => ({ ok: false, reason: 'no transcript to resume' })
 
-  test('DEFAULT (undefined) + transcript exists → RESUME (the warm-asleep contract fix)', () => {
-    expect(resolveWakeMode(cfg(), 'claude-p', '/cwd', undefined, hasTranscript)).toEqual({ resume: true, resumeRef: 'uuid-1' })
+  // ── 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('DEFAULT + NO transcript → FRESH (first-ever launch, not an error)', () => {
-    expect(resolveWakeMode(cfg(), 'claude-p', '/cwd', undefined, noTranscript)).toEqual({ resume: false })
+  test('argsResume=true (attach) + transcript → RESUME', () => {
+    expect(resolveWakeMode(cfg(), 'claude-p', cwd(), true, hasTranscript)).toEqual({ resume: true, resumeRef: 'uuid-1', cause: 'attach' })
   })
-  test('explicit resume=true + nothing to resume → FAIL-LOUD (failReason, no silent fresh)', () => {
-    const m = resolveWakeMode(cfg(), 'claude-p', '/cwd', true, noTranscript)
+  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/)
   })
-  test('explicit resume=false → FRESH', () => {
-    expect(resolveWakeMode(cfg(), 'claude-p', '/cwd', false, hasTranscript)).toEqual({ resume: false })
+
+  // ── 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' })
+  })
+
+  // ── 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('/new-mark present → FRESH and CONSUMES the mark (even if a transcript exists)', () => {
+  test('DEFAULT + idle-reaped + executor + NO incoming topic → RESUME (continue the work)', () => {
     const c = cfg()
-    setNewMark(c, 'claude-p')
-    expect(hasNewMark(c, 'claude-p')).toBe(true)
-    expect(resolveWakeMode(c, 'claude-p', '/cwd', undefined, hasTranscript)).toEqual({ resume: false })
-    expect(hasNewMark(c, 'claude-p')).toBe(false) // consumed
+    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
   })
 })
 
-describe('C4a /new-mark round-trip', () => {
+describe('idle-reaped marker round-trip', () => {
   test('set/has/clear', () => {
-    const stateDir = mkdtempSync(join(tmpdir(), 'iapeer-newmark-'))
+    const stateDir = mkdtempSync(join(tmpdir(), 'iapeer-idlereap-'))
     const cfg = { stateDir } as LifecycleConfig
     try {
-      expect(hasNewMark(cfg, 'claude-y')).toBe(false)
-      setNewMark(cfg, 'claude-y')
-      expect(hasNewMark(cfg, 'claude-y')).toBe(true)
-      clearNewMark(cfg, 'claude-y')
-      expect(hasNewMark(cfg, 'claude-y')).toBe(false)
+      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 })
     }
@@ -393,55 +474,54 @@ describe('C4a /new-mark round-trip', () => {
 })
 
 // ─────────────────────────────────────────────────────────────────────────────
-// C4b — eager fresh re-launch detection (superviseTick flags a dead +/new session)
+// 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('C4b eager fresh re-launch (superviseTick detection)', () => {
-  test('a DEAD session carrying a /new-mark → needs-eager-fresh (mark LEFT for relaunch)', () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-c4b-root-'))
-    const laDir = mkdtempSync(join(tmpdir(), 'iapeer-c4b-la-')) // empty → not launchd-managed
+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 {
-      const env = {
-        ...process.env,
-        IAPEER_ROOT: root,
-        IAPEER_LAUNCHAGENTS_DIR: laDir,
-        IAPEER_SOCK_DIR: join(root, 'socks'), // isolated, no live session here → dead
-      }
-      const cfg = loadLifecycleConfig(env)
-      mkdirSync(cfg.stateDir, { recursive: true })
-      // a session-state for a peer whose session is NOT live (dead)
-      writeFileSync(
-        join(cfg.stateDir, 'claude-z.session'),
-        JSON.stringify({ identity: 'claude-z', runtime: 'claude', personality: 'z', cwd: '/tmp/z', wokeAt: Date.now() }),
-      )
-      setNewMark(cfg, 'claude-z')
+      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 session-state is removed, but the /new-mark is LEFT for the eager
-      // relaunch's resolveWakeMode to consume (so the relaunch resolves to fresh).
-      expect(hasNewMark(cfg, 'claude-z')).toBe(true)
+      // 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('a DEAD session with NO /new-mark → reaped-gone (not eager)', () => {
-    const root = mkdtempSync(join(tmpdir(), 'iapeer-c4b2-root-'))
-    const laDir = mkdtempSync(join(tmpdir(), 'iapeer-c4b2-la-'))
+  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 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-w.session'),
-        JSON.stringify({ identity: 'claude-w', runtime: 'claude', personality: 'w', cwd: '/tmp/w', wokeAt: Date.now() }),
-      )
       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 })
@@ -449,6 +529,71 @@ describe('C4b eager fresh re-launch (superviseTick detection)', () => {
   })
 })
 
+// ─────────────────────────────────────────────────────────────────────────────
+// 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)
 // ─────────────────────────────────────────────────────────────────────────────

package/src/registry/registry.test.ts

@@ -3,6 +3,7 @@ import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import {
+  clampDescription,
   findPeer,
   readPeersIndex,
   removePeer,
@@ -10,7 +11,7 @@ import {
   withPeersLock,
   type PeerRecord,
 } from './index.ts'
-import { defaultIntelligenceForRuntime, type Intelligence } from '../core/constants.ts'
+import { MAX_DESCRIPTION_LEN, defaultIntelligenceForRuntime, type Intelligence } from '../core/constants.ts'
 import { writeFileAtomic, resolvePeersPaths } from '../storage/index.ts'
 
 let root: string
@@ -398,3 +399,34 @@ describe('Companion fix — withPeersLock fail-closed sandbox isolation', () =>
     expect(out).toBe('ok')
   })
 })
+
+// ─────────────────────────────────────────────────────────────────────────────
+// clampDescription boundary — the limit was raised 250 → 450 so self-documenting
+// API-peer descriptions (notifier timer/watcher, ~408 chars) survive intact. The
+// boundary is exact: length == MAX passes untouched, length == MAX+1 truncates.
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('clampDescription — MAX_DESCRIPTION_LEN boundary (450)', () => {
+  test('the limit is 450', () => {
+    expect(MAX_DESCRIPTION_LEN).toBe(450)
+  })
+  test('a 450-char description passes through untouched', () => {
+    const at = 'x'.repeat(450)
+    const r = clampDescription(at)
+    expect(r.truncated).toBe(false)
+    expect(r.description).toBe(at)
+    expect(r.description.length).toBe(450)
+  })
+  test('a 451-char description is truncated to 450', () => {
+    const over = 'y'.repeat(451)
+    const r = clampDescription(over)
+    expect(r.truncated).toBe(true)
+    expect(r.description.length).toBe(450)
+    expect(r.description).toBe('y'.repeat(450))
+  })
+  test('upsertPeer persists a full 450-char description (no clamp at the boundary)', async () => {
+    const desc = 'z'.repeat(450)
+    await upsertPeer({ personality: 'verbose', runtime: 'claude', cwd: '/tmp/verbose', description: desc }, opts())
+    expect(findPeer(readPeersIndex(opts()), 'verbose')!.description).toBe(desc)
+  })
+})