@agfpd/iapeer 0.2.49 → 0.2.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.49",
+  "version": "0.2.50",
   "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;