@agfpd/iapeer 0.2.49 → 0.2.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.49",
+  "version": "0.2.51",
   "description": "Foundation core for the iapeer multi-agent ecosystem: identity, registry, storage, codec.",
   "type": "module",
   "bin": {

package/src/cli/cli.test.ts

@@ -7,10 +7,11 @@ import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
-import { addRuntime, defaultRuntime, formatListTable, listPeers, newPeer, parseArgs, removePeerCli, runCli, sendMessage, startPeer, stopPeer } from './index.ts'
+import { addRuntime, compactPeer, defaultRuntime, formatListTable, listPeers, newPeer, parseArgs, removePeerCli, runCli, sendMessage, startPeer, stopPeer } from './index.ts'
 import { findPeer, readPeersIndex, upsertPeer } from '../registry/index.ts'
 import { hasIdleReaped, isStopped, loadLifecycleConfig, setIdleReaped, setStopped } from '../lifecycle/index.ts'
 import { launchdPlistPath } from '../launch/launchd.ts'
+import { ok } from '../core/errors.ts'
 
 let root: string
 let laDir: string
@@ -452,6 +453,58 @@ describe('new (unconditional fresh restart)', () => {
   })
 })
 
+// ─── compact-resume — control addresses the dialogue, not just a live session ──
+
+describe('compact (resume sleeping dialogue)', () => {
+  test('clean idle-reaped asleep peer → explicit resume wake, then /compact control', async () => {
+    await register('sleepy', 'codex')
+    const e = env()
+    const cfg = loadLifecycleConfig(e)
+    setIdleReaped(cfg, 'codex-sleepy')
+    const wakeCalls: unknown[] = []
+    const controlCalls: unknown[] = []
+    const o = await compactPeer('sleepy', 'codex', {
+      env: e,
+      wakeFn: async args => {
+        wakeCalls.push(args)
+        return { status: 'READY', woke: true, runtime: args.runtime, process_address: `${args.runtime}-${args.personality}`, taskDelivered: true }
+      },
+      controlFn: (personality, runtime, command) => {
+        controlCalls.push({ personality, runtime, command })
+        return ok({ ok: true, controlled: { personality, runtime: runtime! }, command: command.name, ts: 't' })
+      },
+    })
+    expect(o).toMatchObject({ action: 'compacted', runtime: 'codex', woke: true })
+    expect(wakeCalls).toEqual([{ personality: 'sleepy', runtime: 'codex', task: '', resume: true }])
+    expect(controlCalls).toEqual([{ personality: 'sleepy', runtime: 'codex', command: { name: 'compact' } }])
+    expect(hasIdleReaped(cfg, 'codex-sleepy')).toBe(false)
+  })
+
+  test('crashed / first-wake asleep peer (no clean idle marker) → nothing-to-compact, no fresh wake', async () => {
+    await register('freshy', 'codex')
+    let woke = false
+    const o = await compactPeer('freshy', 'codex', {
+      env: env(),
+      wakeFn: async () => ((woke = true), { status: 'READY', woke: true }),
+    })
+    expect(o.action).toBe('nothing-to-compact')
+    expect(o.reason).toContain('nothing to compact')
+    expect(woke).toBe(false)
+  })
+
+  test('idle marker but no transcript/session to resume → nothing-to-compact (not fresh)', async () => {
+    await register('empty', 'codex')
+    const e = env()
+    setIdleReaped(loadLifecycleConfig(e), 'codex-empty')
+    const o = await compactPeer('empty', 'codex', {
+      env: e,
+      wakeFn: async args => ({ status: 'FAILED', woke: false, runtime: args.runtime, reason: 'no codex session to resume' }),
+    })
+    expect(o.action).toBe('nothing-to-compact')
+    expect(o.reason).toContain('nothing to compact')
+  })
+})
+
 // ─── add-runtime / default-runtime — the fleet-switch levers (codex-parity) ───
 
 describe('add-runtime / default-runtime (fleet-switch levers)', () => {

package/src/cli/index.ts

@@ -31,10 +31,12 @@ import {
   clearNewEager,
   clearStopped,
   folderLaunch,
+  hasIdleReaped,
   isLaunchdManaged,
   isEphemeralPeer,
   isStopped,
   killSession,
+  lastActiveRuntime,
   loadLifecycleConfig,
   purgeIdentityState,
   removeSessionState,
@@ -503,6 +505,95 @@ export async function newPeer(
   return { personality, runtime: rt, action: 'fresh' }
 }
 
+export interface CompactPeerOutcome {
+  personality: string
+  runtime: string
+  action: 'compacted' | 'nothing-to-compact' | 'refused-foreign-launchd' | 'refused-infra' | 'refused-undeclared-runtime' | 'failed'
+  woke?: boolean
+  reason?: string
+}
+
+/**
+ * compact <peer> [runtime] — compact the DIALOGUE, not merely the currently-live
+ * session. A live target receives the in-session `/compact` control as before. A
+ * cleanly idle-reaped target is first resumed into the same dialogue, then compacted.
+ * A crashed / never-run / non-resumable target returns an honest "nothing to compact"
+ * instead of starting a fresh empty session and compacting that.
+ */
+export async function compactPeer(
+  personality: string,
+  runtime: string | undefined,
+  opts: CliEnvOptions & {
+    wakeFn?: (args: { personality: string; runtime: Runtime; task: string; resume: true }) => Promise<WakeResult>
+    controlFn?: typeof routeControl
+  } = {},
+): Promise<CompactPeerOutcome> {
+  const env = opts.env ?? process.env
+  const cfg = loadLifecycleConfig(env)
+  const peer = findPeer(readPeersIndex({ env }), personality)
+  if (!peer) throw new Error(`peer "${personality}" is not registered`)
+  if (isForeignLaunchd(personality, env)) {
+    return {
+      personality,
+      runtime: peer.runtime,
+      action: 'refused-foreign-launchd',
+      reason: `"${personality}" is managed by persistent-peer (foreign launchd plist) — the foundation does not control it`,
+    }
+  }
+  if (runtime && !isRuntime(runtime)) throw new Error(`invalid runtime "${runtime}"`)
+  if (runtime && peer.runtime !== runtime && !peer.runtimes.includes(runtime as Runtime)) {
+    return {
+      personality,
+      runtime,
+      action: 'refused-undeclared-runtime',
+      reason: `peer "${personality}" does not declare runtime "${runtime}" (declared: ${peer.runtimes.join(', ')})`,
+    }
+  }
+
+  const control = opts.controlFn ?? routeControl
+  const liveRuntimes = peer.runtimes.filter(rt => isPeerLive(rt, personality, cfg.sockDir))
+  if (runtime ? liveRuntimes.includes(runtime as Runtime) : liveRuntimes.length > 0) {
+    const r = control(personality, runtime, { name: 'compact' })
+    if (!r.ok) return { personality, runtime: runtime ?? peer.runtime, action: 'failed', reason: r.error.message }
+    return { personality, runtime: r.value.controlled.runtime, action: 'compacted', woke: false }
+  }
+
+  const rt: Runtime = (runtime as Runtime | undefined) ?? lastActiveRuntime(peer, cfg) ?? peer.runtime
+  if (!peer.runtimes.includes(rt)) {
+    return {
+      personality,
+      runtime: rt,
+      action: 'refused-undeclared-runtime',
+      reason: `peer "${personality}" does not declare runtime "${rt}" (declared: ${peer.runtimes.join(', ')})`,
+    }
+  }
+  if (isInfraRuntime(rt)) {
+    return {
+      personality,
+      runtime: rt,
+      action: 'refused-infra',
+      reason: `infra runtime "${rt}" is launchd-held and has no compactable TUI dialogue`,
+    }
+  }
+  const identity = buildProcessAddress(rt, personality)
+  if (!hasIdleReaped(cfg, identity)) {
+    return { personality, runtime: rt, action: 'nothing-to-compact', reason: 'context is fresh; nothing to compact' }
+  }
+  const wake = opts.wakeFn ?? (args => wakeOrSpawn(args, { cfg, env }))
+  const w = await wake({ personality, runtime: rt, task: '', resume: true })
+  if (w.status !== 'READY') {
+    const reason = w.reason ?? 'wake failed'
+    if (/no .*session to resume|no transcript to resume|nothing to resume/i.test(reason)) {
+      return { personality, runtime: rt, action: 'nothing-to-compact', reason: 'context is fresh; nothing to compact' }
+    }
+    return { personality, runtime: rt, action: 'failed', reason }
+  }
+  clearIdleReaped(cfg, identity)
+  const r = control(personality, rt, { name: 'compact' })
+  if (!r.ok) return { personality, runtime: rt, action: 'failed', woke: true, reason: r.error.message }
+  return { personality, runtime: rt, action: 'compacted', woke: true }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // remove — delete a peer's record from the registry through the LOCKED writer
 // (registry.removePeer). Direct edits of peers-profiles.json are refused at
@@ -804,7 +895,7 @@ const USAGE = `usage: iapeer <verb> [args]
   default-runtime <runtime> (--peer <p> | --all)                 flip the PRIMARY (routing/wake default) — the fleet-switch lever; refuses an undeclared runtime; registry self-healed in the same command
   attach <peer> [runtime]                                        ensure-live + resume, then tmux attach
   interrupt <peer> [runtime]                                     interrupt the current turn (Escape) — context intact
-  compact <peer> [runtime]                                       compact the peer's context (/compact)
+  compact <peer> [runtime]                                       compact the peer's dialogue (/compact); resumes clean-asleep first
   self-fresh                                                     (agent self-call) mark /new eager-fresh + self-kill — the daemon relaunches fresh
   self-done                                                      (agent self-call, ephemeral) silent finish: arm own quiet-reap, wake no one
   native-memory <off|on> (--peer <p> | --all)                    gate/restore runtimes' native memory (canonized lever; контракт «Слот памяти»)
@@ -1521,10 +1612,9 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         killSession(sock, identity)
         return 0
       }
-      case 'interrupt':
-      case 'compact': {
+      case 'interrupt': {
         // In-session control (Ф-E, clean-slash namespace): interrupt a stuck/raving
-        // turn (Escape) / compact context. UNCONDITIONAL — acts on the live session.
+        // turn (Escape). UNCONDITIONAL — acts on the live session.
         if (!positionals[0]) return usage(errOut)
         const r = routeControl(positionals[0], positionals[1], { name: verb })
         if (!r.ok) {
@@ -1534,6 +1624,19 @@ export async function runCli(argv: string[], env: NodeJS.ProcessEnv = process.en
         out(`${verb} → ${r.value.controlled.personality} (${r.value.controlled.runtime})\n`)
         return 0
       }
+      case 'compact': {
+        // Dialogue control (UX directive 12.06): if the session is merely asleep
+        // after a clean idle-reap, resume the same dialogue and compact it; if there
+        // is no resumable dialogue, fail honestly instead of compacting a fresh one.
+        if (!positionals[0]) return usage(errOut)
+        const o = await compactPeer(positionals[0], positionals[1], { env })
+        if (o.action === 'compacted') {
+          out(`compact → ${o.personality} (${o.runtime})${o.woke ? ' after resume' : ''}\n`)
+          return 0
+        }
+        errOut(`compact: ${o.personality} (${o.runtime}): ${o.action}${o.reason ? ` — ${o.reason}` : ''}\n`)
+        return 1
+      }
       case 'connect': {
         // Per-peer channel attachment in ONE flow (design «Onboard костяка» §(в)):
         // `connect telegram <peer> [--token <t>]`. The human owes only the token;

package/src/launch/canary.test.ts

@@ -69,7 +69,8 @@ describe('canary script (pure)', () => {
     // proven live); the SERVER's liveness decides, after a dismissal grace sleep.
     expect(s).not.toContain(`[ "$rc" -eq 0 ] || [ "$rc" -ge 128 ]; then exit 0`) // the v1 hole
     expect(s).toContain('sleep 2') // dismissal grace window
-    expect(s).toContain(`has-session 2>/dev/null; then exit 0`) // server alive → nothing to record
+    expect(s).toContain(`kill -0 "$SPID" 2>/dev/null; then exit 0`) // original server alive → nothing to record
+    expect(s).toContain(`[ -z "$SPID" ]`) // fallback only when the original pid was unavailable
     expect(s).toContain('cause=server-vanished') // connection drop (SIGKILL/OOM class)
     expect(s).toContain('cause=signaled-server-gone') // rc=0: channel/client-TERM, server died
     expect(s).toContain('cause=client-killed-server-gone') // rc≥128: client took a hard kill
@@ -119,6 +120,7 @@ describe.if(tmuxAvailable)('canary live (sandbox tmux servers)', () => {
     'notifier-canatear',
     'claude-canasweep',
     'claude-canaclient',
+    'claude-canareplaced',
   ]
 
   afterAll(() => {
@@ -285,4 +287,44 @@ describe.if(tmuxAvailable)('canary live (sandbox tmux servers)', () => {
     },
     20000,
   )
+
+  test(
+    'dirty server death followed by immediate replacement on the same socket still records the ORIGINAL death',
+    async () => {
+      const identity = 'claude-canareplaced'
+      const { sock, logDir } = bringUp(identity)
+      const pid = serverPid(sock)
+      expect(pid).toBeGreaterThan(0)
+      expect(ensureServerCanary({ identity, sock, exitLogDir: logDir })).toBe('spawned')
+      expect(await waitFor(() => canaryRunning(identity), 3000)).toBe(true)
+      await sleep(500)
+
+      process.kill(pid, 'SIGKILL')
+      // Reuse the same socket before the canary's 2s dismissal-grace window
+      // expires. The old socket-level probe treated this successor as "server
+      // alive" and lost the predecessor's death; the canary must key on SPID.
+      let started = false
+      for (let i = 0; i < 20; i++) {
+        const r = spawnSync('tmux', ['-S', sock, 'new-session', '-d', '-s', identity, 'sleep', '120'], {
+          stdio: 'ignore',
+        })
+        if (r.status === 0) {
+          started = true
+          break
+        }
+        await sleep(50)
+      }
+      expect(started).toBe(true)
+
+      const log = exitLogPath(logDir)
+      expect(await waitFor(() => existsSync(log) && readFileSync(log, 'utf8').includes('ev=server-exit'), 8000)).toBe(
+        true,
+      )
+      const line = readFileSync(log, 'utf8')
+      expect(line).toContain(`ev=server-exit identity=${identity}`)
+      expect(line).toContain(`server_pid=${pid}`)
+      expect(readdirSync(serverDeathsDir(logDir)).length).toBe(1)
+    },
+    20000,
+  )
 })

package/src/launch/canary.ts

@@ -19,14 +19,18 @@
 //     sh recorder (`dismissCanary` → TERM → trap → silent exit). POSIX trap
 //     semantics make this race-free: the trap runs before any recording.
 //   • When wait-for returns — ANY code — the script sleeps 2 s (a concurrent
-//     dismissal TERM wins here), then probes SERVER LIVENESS: alive → exit
-//     silently (a lost canary is re-armed and logged by the supervise retrofit
-//     within a tick); dead with nobody having dismissed us → the death is real
-//     and unclaimed → ONE logfmt line `ev=server-exit` into exits.log (the
-//     per-peer death-cause home, next to pane-died's `ev=session-exit`) + a
-//     forensics snapshot (vm_stat / swap / top-RSS ps / fresh DiagnosticReports)
-//     captured within seconds — the evidence the 60 s supervise tick can never
-//     recover ("системных следов ноль" was the recurring investigation outcome).
+//     dismissal TERM wins here), then probes the ORIGINAL SERVER PID captured at
+//     arm time: still alive → exit silently (a lost canary is re-armed and logged
+//     by the supervise retrofit within a tick); gone with nobody having dismissed
+//     us → the death is real and unclaimed → ONE logfmt line `ev=server-exit`
+//     into exits.log (the per-peer death-cause home, next to pane-died's
+//     `ev=session-exit`) + a forensics snapshot (vm_stat / swap / top-RSS ps /
+//     fresh DiagnosticReports) captured within seconds — the evidence the 60 s
+//     supervise tick can never recover ("системных следов ноль" was the recurring
+//     investigation outcome). PID identity matters: a wake/attach can replace the
+//     tmux server on the same socket before the 2 s grace elapses; probing only
+//     the socket would mistake the successor for the dead original and lose the
+//     canary record (live canary-gap 11.06).
 //     The raw wait_rc still ATTRIBUTES the death (cause=server-vanished /
 //     signaled-server-gone / client-killed-server-gone).
 // Residual blind spot (structural): a killer that SIGKILLs the sh recorder
@@ -98,12 +102,16 @@ export function canaryScript(o: CanaryScriptOptions): string {
     // `rc=0 || rc>=128 → silent` was exactly that hole). v2 contract instead:
     //   • deliberate teardowns DISMISS this sh (TERM → trap above) — the sleep
     //     below gives a concurrently-delivered dismissal time to win;
-    //   • then the SERVER's liveness, not the exit code, decides: alive →
+    //   • then the ORIGINAL SERVER PID's liveness, not the exit code, decides: alive →
     //     nothing to record (a lost canary is re-armed and logged by the
-    //     supervise retrofit within a tick); dead and nobody dismissed us →
-    //     the death is real and unclaimed → record it.
+    //     supervise retrofit within a tick); original server dead and nobody
+    //     dismissed us → the death is real and unclaimed → record it. IMPORTANT:
+    //     check the ORIGINAL SPID, not merely "some server answers on the same
+    //     socket". A wake/attach can replace the server inside this 2 s window;
+    //     socket-liveness would then silently swallow the predecessor's death.
     `sleep 2`,
-    `if '${o.tmuxBin}' -S '${o.sock}' has-session 2>/dev/null; then exit 0; fi`,
+    `if [ -n "$SPID" ] && kill -0 "$SPID" 2>/dev/null; then exit 0; fi`,
+    `if [ -z "$SPID" ] && '${o.tmuxBin}' -S '${o.sock}' has-session 2>/dev/null; then exit 0; fi`,
     // The exit code still ATTRIBUTES the recorded death (raw wait_rc is kept):
     //   rc=0   → signaled-server-gone   (channel signal or client-TERM, server died)
     //   rc≥128 → client-killed-server-gone (client took a non-TERM kill)