@agfpd/iapeer 0.2.76 → 0.2.78

package/src/lifecycle/queue.test.ts

@@ -1,185 +0,0 @@
-// Ephemeral serial queue (M3) — FIFO primitives + the drain consumer.
-// Retry semantics (boris acceptance (b)) are pinned here: a FAILED wake leaves
-// the item at the head and the NEXT drain call retries the SAME task; only a
-// READY wake consumes it. Strict FIFO order is asserted across drains.
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { spawnSync } from 'child_process'
-import {
-  drainAllEphemeralQueues,
-  drainEphemeralQueue,
-  enqueueEphemeralTask,
-  ephemeralQueueDepth,
-  ephemeralQueueDir,
-  listQueuedIdentities,
-  peekEphemeralTask,
-  removeEphemeralTask,
-  type LifecycleConfig,
-  type WakeArgs,
-  type WakeResult,
-} from './index.ts'
-
-const dirs: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-equeue-'))
-  dirs.push(d)
-  return d
-}
-afterEach(() => {
-  while (dirs.length) rmSync(dirs.pop()!, { recursive: true, force: true })
-})
-
-function mkCfg(): LifecycleConfig {
-  const root = mkTmp()
-  return {
-    stateDir: join(root, 'state'),
-    sockDir: join(root, 'socks'),
-    eventLogDir: join(root, 'logs'),
-  } as LifecycleConfig
-}
-
-describe('ephemeral queue primitives (FIFO)', () => {
-  test('enqueue returns depth; peek is non-destructive; remove consumes; strict FIFO', () => {
-    const cfg = mkCfg()
-    expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(0)
-    expect(peekEphemeralTask(cfg, 'claude-w')).toBeNull()
-
-    expect(enqueueEphemeralTask(cfg, 'claude-w', { task: 'first', topic: 't1' })).toBe(1)
-    expect(enqueueEphemeralTask(cfg, 'claude-w', { task: 'second' })).toBe(2)
-    expect(enqueueEphemeralTask(cfg, 'claude-w', { task: 'third', topic: 't3' })).toBe(3)
-
-    const head = peekEphemeralTask(cfg, 'claude-w')
-    expect(head?.task).toBe('first')
-    expect(head?.topic).toBe('t1')
-    expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(3) // peek did not consume
-
-    removeEphemeralTask(cfg, 'claude-w', head!.seq)
-    removeEphemeralTask(cfg, 'claude-w', head!.seq) // idempotent
-    expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(2)
-    expect(peekEphemeralTask(cfg, 'claude-w')?.task).toBe('second')
-    expect(peekEphemeralTask(cfg, 'claude-w')?.topic).toBeUndefined()
-  })
-
-  test('enqueue skips taken seq names (exclusive-create) — no overwrite of a pending task', () => {
-    const cfg = mkCfg()
-    enqueueEphemeralTask(cfg, 'claude-w', { task: 'one' })
-    // simulate a competitor that already claimed the next seq
-    writeFileSync(join(ephemeralQueueDir(cfg, 'claude-w'), '000002'), JSON.stringify({ task: 'competitor' }))
-    expect(enqueueEphemeralTask(cfg, 'claude-w', { task: 'three' })).toBe(3)
-    // all three distinct tasks live side-by-side
-    const dir = ephemeralQueueDir(cfg, 'claude-w')
-    expect(JSON.parse(readFileSync(join(dir, '000002'), 'utf8')).task).toBe('competitor')
-    expect(JSON.parse(readFileSync(join(dir, '000003'), 'utf8')).task).toBe('three')
-  })
-
-  test('a poison head (corrupt JSON) is dropped, not wedging the queue', () => {
-    const cfg = mkCfg()
-    mkdirSync(ephemeralQueueDir(cfg, 'claude-w'), { recursive: true })
-    writeFileSync(join(ephemeralQueueDir(cfg, 'claude-w'), '000001'), 'NOT JSON {{{')
-    enqueueEphemeralTask(cfg, 'claude-w', { task: 'good' })
-    const head = peekEphemeralTask(cfg, 'claude-w')
-    expect(head?.task).toBe('good')
-    expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(1) // poison slot dropped
-  })
-
-  test('listQueuedIdentities: only non-empty queues, sorted', () => {
-    const cfg = mkCfg()
-    enqueueEphemeralTask(cfg, 'claude-b', { task: 'x' })
-    enqueueEphemeralTask(cfg, 'claude-a', { task: 'y' })
-    mkdirSync(ephemeralQueueDir(cfg, 'claude-empty'), { recursive: true }) // empty dir → excluded
-    expect(listQueuedIdentities(cfg)).toEqual(['claude-a', 'claude-b'])
-  })
-})
-
-describe('drainEphemeralQueue (peek → wake → rm-on-READY)', () => {
-  function fakeWake(
-    script: Array<'READY' | 'FAILED'>,
-    calls: WakeArgs[],
-  ): (args: WakeArgs) => Promise<WakeResult> {
-    return async args => {
-      calls.push(args)
-      const status = script[Math.min(calls.length - 1, script.length - 1)]!
-      return { status, woke: status === 'READY', runtime: 'claude' }
-    }
-  }
-
-  test('empty queue → null, wake NOT called', async () => {
-    const cfg = mkCfg()
-    const calls: WakeArgs[] = []
-    expect(await drainEphemeralQueue(cfg, 'w', 'claude', { wakeFn: fakeWake(['READY'], calls) })).toBeNull()
-    expect(calls).toEqual([])
-  })
-
-  test('READY consumes the head; successive drains feed tasks in STRICT FIFO order', async () => {
-    const cfg = mkCfg()
-    enqueueEphemeralTask(cfg, 'claude-w', { task: 'task-A', topic: 'ta' })
-    enqueueEphemeralTask(cfg, 'claude-w', { task: 'task-B' })
-    const calls: WakeArgs[] = []
-    const deps = { wakeFn: fakeWake(['READY'], calls) }
-
-    expect((await drainEphemeralQueue(cfg, 'w', 'claude', deps))?.status).toBe('READY')
-    expect(calls[0]).toMatchObject({ personality: 'w', runtime: 'claude', task: 'task-A', topic: 'ta' })
-    expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(1) // A consumed
-
-    expect((await drainEphemeralQueue(cfg, 'w', 'claude', deps))?.status).toBe('READY')
-    expect(calls[1]).toMatchObject({ task: 'task-B' }) // FIFO: B strictly after A
-    expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(0)
-    expect(await drainEphemeralQueue(cfg, 'w', 'claude', deps)).toBeNull() // drained dry
-
-    // durable drain trace (acceptance (a)): ev=ephemeral-drain with depth
-    const logged = readFileSync(join(cfg.eventLogDir, 'lifecycle.log'), 'utf8')
-    expect(logged).toContain('ev=ephemeral-drain')
-    expect(logged).toContain('identity=claude-w')
-    expect(logged).toContain('depth=2')
-  })
-
-  test('FAILED wake LEAVES the item at the head — the next drain RETRIES the same task (acceptance (b))', async () => {
-    const cfg = mkCfg()
-    enqueueEphemeralTask(cfg, 'claude-w', { task: 'flaky-task' })
-    const calls: WakeArgs[] = []
-    const deps = { wakeFn: fakeWake(['FAILED', 'READY'], calls) }
-
-    expect((await drainEphemeralQueue(cfg, 'w', 'claude', deps))?.status).toBe('FAILED')
-    expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(1) // NOT consumed on failure
-
-    expect((await drainEphemeralQueue(cfg, 'w', 'claude', deps))?.status).toBe('READY')
-    expect(calls.length).toBe(2)
-    expect(calls[1]?.task).toBe('flaky-task') // the SAME task, retried
-    expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(0)
-  })
-
-  const tmuxAvailable = spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0
-  test.if(tmuxAvailable)('a LIVE session blocks the drain (one task per session invariant)', async () => {
-    const cfg = mkCfg()
-    mkdirSync(cfg.sockDir, { recursive: true })
-    const sock = join(cfg.sockDir, 'tmux-iap-claude-w.sock')
-    enqueueEphemeralTask(cfg, 'claude-w', { task: 'queued-while-busy' })
-    const calls: WakeArgs[] = []
-    try {
-      spawnSync('tmux', ['-S', sock, 'new-session', '-d', '-s', 'claude-w', 'sleep', '60'])
-      expect(await drainEphemeralQueue(cfg, 'w', 'claude', { wakeFn: fakeWake(['READY'], calls) })).toBeNull()
-      expect(calls).toEqual([]) // no wake while the session lives
-      expect(ephemeralQueueDepth(cfg, 'claude-w')).toBe(1) // task waits for the reap
-    } finally {
-      spawnSync('tmux', ['-S', sock, 'kill-server'], { stdio: 'ignore' })
-    }
-  })
-
-  test('drainAllEphemeralQueues: scans every queued identity, H4-skips launchd-managed', async () => {
-    const cfg = mkCfg()
-    const laDir = mkTmp()
-    const env = { ...process.env, IAPEER_LAUNCHAGENTS_DIR: laDir } as NodeJS.ProcessEnv
-    enqueueEphemeralTask(cfg, 'claude-free', { task: 'x' })
-    enqueueEphemeralTask(cfg, 'claude-held', { task: 'y' })
-    writeFileSync(join(laDir, 'com.iapeer.held.plist'), '') // 'held' is launchd-managed
-    const calls: WakeArgs[] = []
-    const results = await drainAllEphemeralQueues(cfg, { env, wakeFn: fakeWake(['READY'], calls) })
-    expect(results.length).toBe(1)
-    expect(calls.map(c => c.personality)).toEqual(['free']) // held NEVER woken (H4)
-    expect(ephemeralQueueDepth(cfg, 'claude-free')).toBe(0)
-    expect(ephemeralQueueDepth(cfg, 'claude-held')).toBe(1) // untouched
-  })
-})

package/src/onboard/memory.test.ts

@@ -1,157 +0,0 @@
-// onboardMemoryProvider — the host-phase memory-slot step (контракт «Слот
-// памяти»). Default-YES, report-only for the exit code; the PROVIDER writes the
-// slot declaration (the step verifies it did). All writes under a temp
-// IAPEER_ROOT — never the live host.
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { coreKnownInitArgs, onboardMemoryProvider, DEFAULT_MEMORY_PACKAGE } from './memory.ts'
-import { memoryProviderPath } from '../status/index.ts'
-
-const dirs: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-memstep-'))
-  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 SLOT = {
-  provider: 'iapeer-memory',
-  package: DEFAULT_MEMORY_PACKAGE,
-  version: '0.1.0',
-  registeredAt: '2026-06-10T00:00:00Z',
-}
-
-function registry(root: string, naturals: string[]): void {
-  writeFileSync(
-    join(root, 'peers-profiles.json'),
-    JSON.stringify({
-      version: 2,
-      peers: [
-        ...naturals.map(p => ({ personality: p, runtime: 'telegram', runtimes: ['telegram'], description: '', intelligence: 'natural', cwd: `/tmp/${p}` })),
-        { personality: 'bot', runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial', cwd: '/tmp/bot' },
-      ],
-    }),
-  )
-}
-
-describe('coreKnownInitArgs (the EXHAUSTIVE v1 passthrough list)', () => {
-  test('exactly one natural peer → --human <personality>', () => {
-    const root = mkTmp()
-    registry(root, ['arthur'])
-    expect(coreKnownInitArgs(envFor(root))).toEqual(['--human', 'arthur'])
-  })
-  test('zero or many naturals → pass NOTHING (the provider asks itself)', () => {
-    const none = mkTmp()
-    registry(none, [])
-    expect(coreKnownInitArgs(envFor(none))).toEqual([])
-    const many = mkTmp()
-    registry(many, ['arthur', 'maria'])
-    expect(coreKnownInitArgs(envFor(many))).toEqual([])
-  })
-  test('legacy intelligence "human" normalizes to natural (read-compat)', () => {
-    const root = mkTmp()
-    writeFileSync(
-      join(root, 'peers-profiles.json'),
-      JSON.stringify({ version: 2, peers: [{ personality: 'arthur', runtime: 'telegram', runtimes: ['telegram'], description: '', intelligence: 'human', cwd: '/tmp/a' }] }),
-    )
-    expect(coreKnownInitArgs(envFor(root))).toEqual(['--human', 'arthur'])
-  })
-  test('no registry at all → [] (never throws)', () => {
-    expect(coreKnownInitArgs(envFor(mkTmp()))).toEqual([])
-  })
-})
-
-describe('onboardMemoryProvider', () => {
-  test('--no-memory → skipped-flag, init never invoked', async () => {
-    const root = mkTmp()
-    let invoked = 0
-    const r = await onboardMemoryProvider({
-      skip: true,
-      env: envFor(root),
-      runInit: () => ((invoked++), { status: 0, unavailable: false }),
-    })
-    expect(r.state).toBe('skipped-flag')
-    expect(invoked).toBe(0)
-  })
-
-  test('same package already in the slot → already (idempotent no-op, no init call)', async () => {
-    const root = mkTmp()
-    writeFileSync(memoryProviderPath(envFor(root)), JSON.stringify(SLOT))
-    let invoked = 0
-    const r = await onboardMemoryProvider({
-      env: envFor(root),
-      runInit: () => ((invoked++), { status: 0, unavailable: false }),
-    })
-    expect(r.state).toBe('already')
-    expect(r.provider?.provider).toBe('iapeer-memory')
-    expect(invoked).toBe(0)
-  })
-
-  test('slot occupied by ANOTHER provider → refused-foreign (never silent overwrite)', async () => {
-    const root = mkTmp()
-    writeFileSync(memoryProviderPath(envFor(root)), JSON.stringify({ ...SLOT, provider: 'other-mem', package: '@x/other' }))
-    const r = await onboardMemoryProvider({ env: envFor(root), runInit: () => ({ status: 0, unavailable: false }) })
-    expect(r.state).toBe('refused-foreign')
-    expect(r.detail).toMatch(/occupied .*other-mem.*uninstall/)
-  })
-
-  test('dry-run → reports the exact would-be command incl. --human passthrough', async () => {
-    const root = mkTmp()
-    registry(root, ['arthur'])
-    const r = await onboardMemoryProvider({ dryRun: true, env: envFor(root) })
-    expect(r.state).toBe('dry-run')
-    expect(r.detail).toBe(`would run: npx -y ${DEFAULT_MEMORY_PACKAGE} init --human arthur`)
-  })
-
-  test('package unavailable → skipped-unavailable (SOFT skip — release order never blocks onboard)', async () => {
-    const root = mkTmp()
-    registry(root, [])
-    const r = await onboardMemoryProvider({ env: envFor(root), runInit: () => ({ status: 1, unavailable: true }) })
-    expect(r.state).toBe('skipped-unavailable')
-    expect(r.detail).toMatch(/not available/)
-  })
-
-  test('init ok + provider declared the slot → installed (slot read back)', async () => {
-    const root = mkTmp()
-    registry(root, ['arthur'])
-    const env = envFor(root)
-    const calls: string[][] = []
-    const r = await onboardMemoryProvider({
-      env,
-      runInit: (pkg, args) => {
-        calls.push([pkg, ...args])
-        writeFileSync(memoryProviderPath(env), JSON.stringify(SLOT)) // the PROVIDER writes the slot
-        return { status: 0, unavailable: false }
-      },
-    })
-    expect(r.state).toBe('installed')
-    expect(r.provider?.version).toBe('0.1.0')
-    expect(calls).toEqual([[DEFAULT_MEMORY_PACKAGE, 'init', '--human', 'arthur']])
-  })
-
-  test('init ok but slot NOT declared → provider-init-failed (its contract duty, surfaced)', async () => {
-    const root = mkTmp()
-    registry(root, [])
-    const r = await onboardMemoryProvider({ env: envFor(root), runInit: () => ({ status: 0, unavailable: false }) })
-    expect(r.state).toBe('provider-init-failed')
-    expect(r.detail).toMatch(/did not declare/)
-  })
-
-  test('init non-zero (e.g. non-tty refusal) → provider-init-failed with the exit code', async () => {
-    const root = mkTmp()
-    registry(root, [])
-    const r = await onboardMemoryProvider({ env: envFor(root), runInit: () => ({ status: 2, unavailable: false }) })
-    expect(r.state).toBe('provider-init-failed')
-    expect(r.detail).toMatch(/exited 2/)
-  })
-})

package/src/onboard/onboard.test.ts

@@ -1,39 +0,0 @@
-// onboard — the fleet-critical detector (isAgfpdInList): is OUR marketplace already
-// registered? A false negative would RE-register on an already-configured host (the
-// exact fleet-mutation onboard must avoid). Tested against REAL claude/codex
-// `plugin marketplace list` output shapes.
-
-import { describe, expect, test } from 'bun:test'
-import { isAgfpdInList } from './index.ts'
-
-describe('isAgfpdInList (marketplace-registered detector)', () => {
-  test('claude list shape (❯ name + GitHub source ref) → true', () => {
-    const claudeOut = `Configured marketplaces:
-
-  ❯ claude-plugins-official
-    Source: GitHub (anthropics/claude-plugins-official)
-
-  ❯ agfpd
-    Source: GitHub (agfpd/agfpd-marketplace)
-`
-    expect(isAgfpdInList(claudeOut)).toBe(true)
-  })
-
-  test('codex list shape (name + root path columns) → true', () => {
-    const codexOut = `MARKETPLACE              ROOT
-agfpd                    /Users/x/.codex/.tmp/marketplaces/agfpd
-claude-plugins-official  /Users/x/.codex/.tmp/marketplaces/claude-plugins-official
-`
-    expect(isAgfpdInList(codexOut)).toBe(true)
-  })
-
-  test('NOT registered (only other marketplaces) → false', () => {
-    expect(isAgfpdInList('Configured marketplaces:\n\n  ❯ claude-plugins-official\n    Source: GitHub (anthropics/claude-plugins-official)\n')).toBe(false)
-    expect(isAgfpdInList('')).toBe(false)
-  })
-
-  test('a different agfpd-* token (e.g. a plugin name) does NOT false-positive', () => {
-    // a line that mentions agfpd-prompt-architect but the agfpd marketplace is NOT listed
-    expect(isAgfpdInList('plugins:\n  agfpd-prompt-architect@somewhere (installed)\n')).toBe(false)
-  })
-})

package/src/onboard/steps.test.ts

@@ -1,201 +0,0 @@
-// Backbone default-yes onboard steps (design «Onboard костяка» FINAL 10.06) —
-// notifier (zero questions, soft-skip on unavailability) and telegram (human peer
-// via TELEGRAM_USER_ID env → the package's self-config hook; idempotent vs an
-// existing natural peer). All sandboxed: IAPEER_ROOT / IAPEER_LAUNCHAGENTS_DIR
-// temp dirs, IAPEER_TEST_SANDBOX skips real launchctl, injected npx/ask.
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { findNaturalPeer, onboardNotifierStep, onboardTelegramStep } from './steps.ts'
-import { writeRuntimeManifest, type RuntimeManifest } from '../runtime/index.ts'
-import { findPeer, readPeersIndex, upsertPeer } from '../registry/index.ts'
-
-const roots: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-steps-'))
-  roots.push(d)
-  return d
-}
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function envFor(root: string, path?: string): NodeJS.ProcessEnv {
-  return {
-    IAPEER_ROOT: join(root, 'iapeer'),
-    IAPEER_LAUNCHAGENTS_DIR: join(root, 'LA'),
-    IAPEER_TEST_SANDBOX: '1',
-    HOME: root,
-    ...(path ? { PATH: path } : {}),
-  } as NodeJS.ProcessEnv
-}
-
-/** Stub launcher + recording self-config hook on a PATH dir. */
-function stubBins(bin: string): { dir: string; hook: string } {
-  const dir = mkTmp()
-  writeFileSync(join(dir, bin), '#!/bin/sh\nexec sleep 1\n', { mode: 0o755 })
-  const hook = join(dir, 'sc.sh')
-  // records personality + the TELEGRAM_USER_ID it received → proves env passthrough
-  writeFileSync(
-    hook,
-    '#!/bin/sh\nprintf "%s|%s" "$IAPEER_PEER_PERSONALITY" "$TELEGRAM_USER_ID" > "$IAPEER_ROOT/sc-$IAPEER_PEER_PERSONALITY"\nexit 0\n',
-    { mode: 0o755 },
-  )
-  return { dir, hook }
-}
-
-describe('onboardNotifierStep (а — default-yes, zero questions)', () => {
-  test('npx self-deploy → declared set provisioned', async () => {
-    const root = mkTmp()
-    const { dir, hook } = stubBins('notifier-runtime')
-    const env = envFor(root, dir)
-    const runNpx = (_pkg: string, e: NodeJS.ProcessEnv) => {
-      const m: RuntimeManifest = {
-        runtime: 'notifier',
-        selfConfig: hook,
-        peers: [
-          { personality: 'timer', intelligence: 'absent' },
-          { personality: 'watcher', intelligence: 'absent' },
-        ],
-      }
-      writeRuntimeManifest(m, { env: e })
-      return { ok: true }
-    }
-    const r = await onboardNotifierStep({ env, runNpx })
-    expect(r.state).toBe('deployed')
-    expect(r.peers.map(p => p.personality).sort()).toEqual(['timer', 'watcher'])
-    expect(findPeer(readPeersIndex({ env }), 'timer')).not.toBeNull()
-  })
-
-  test('npx failure (no bun / unpublished / no network) → SOFT skip, not a failure', async () => {
-    const env = envFor(mkTmp())
-    const r = await onboardNotifierStep({ env, runNpx: () => ({ ok: false, detail: 'bun: command not found' }) })
-    expect(r.state).toBe('skipped-unavailable')
-    expect(r.detail).toContain('bun: command not found')
-    expect(r.detail).toContain('install later')
-  })
-
-  test('package installed but manifest missing → deploy-failed (REAL break, not unavailability)', async () => {
-    const env = envFor(mkTmp())
-    // npx "succeeds" but self-deploys nothing — the package broke its contract
-    const r = await onboardNotifierStep({ env, runNpx: () => ({ ok: true }) })
-    expect(r.state).toBe('deploy-failed')
-    expect(r.detail).toContain('manifest')
-  })
-
-  test('--no-notifier → skipped-flag; dry-run reports intent without touching anything', async () => {
-    const env = envFor(mkTmp())
-    expect((await onboardNotifierStep({ skip: true, env })).state).toBe('skipped-flag')
-    const dry = await onboardNotifierStep({ dryRun: true, env })
-    expect(dry.state).toBe('dry-run')
-    expect(dry.detail).toContain('@agfpd/notifier-runtime')
-  })
-
-  test('idempotent re-run: manifest present → install skipped, deploy no-clobber', async () => {
-    const root = mkTmp()
-    const { dir, hook } = stubBins('notifier-runtime')
-    const env = envFor(root, dir)
-    writeRuntimeManifest(
-      { runtime: 'notifier', selfConfig: hook, peers: [{ personality: 'timer', intelligence: 'absent' }] },
-      { env },
-    )
-    let npxCalled = false
-    const first = await onboardNotifierStep({ env, runNpx: () => ((npxCalled = true), { ok: true }) })
-    expect(first.state).toBe('deployed')
-    expect(npxCalled).toBe(false) // manifest-gated — npx never re-ran
-    const second = await onboardNotifierStep({ env, runNpx: () => ({ ok: true }) })
-    expect(second.state).toBe('deployed') // no-clobber re-verify
-    expect(readPeersIndex({ env }).peers.filter(p => p.personality === 'timer').length).toBe(1)
-  })
-})
-
-describe('onboardTelegramStep (б — human peer, идемпотентность, non-tty)', () => {
-  test('flags path: creates the human peer; TELEGRAM_USER_ID reaches the self-config hook', async () => {
-    const root = mkTmp()
-    const { dir, hook } = stubBins('telegram-runtime')
-    const env = envFor(root, dir)
-    writeRuntimeManifest({ runtime: 'telegram', selfConfig: hook }, { env }) // installed (mode b — no declared peers)
-    const r = await onboardTelegramStep({ human: 'Arthur', userId: '123456789', env })
-    expect(r.state).toBe('created')
-    expect(r.personality).toBe('arthur') // normalized
-    const peer = findPeer(readPeersIndex({ env }), 'arthur')!
-    expect(peer.intelligence).toBe('natural')
-    expect(peer.runtime).toBe('telegram')
-    // the hook saw the user id via env (owner's contract: hook writes interfaces itself)
-    expect(readFileSync(join(env.IAPEER_ROOT as string, 'sc-arthur'), 'utf8')).toBe('arthur|123456789')
-  })
-
-  test('IDEMPOTENT: an existing natural peer → already, NEVER a second human (boris check)', async () => {
-    const env = envFor(mkTmp())
-    await upsertPeer(
-      { personality: 'arthur', runtime: 'telegram', cwd: '/tmp/arthur', intelligence: 'natural' },
-      { env },
-    )
-    let asked = false
-    const r = await onboardTelegramStep({
-      env,
-      ask: async () => ((asked = true), 'never'),
-      isTty: true,
-    })
-    expect(r.state).toBe('already')
-    expect(r.personality).toBe('arthur')
-    expect(r.detail).toContain('уже есть')
-    expect(asked).toBe(false) // no questions, no install — the WHOLE step no-ops
-  })
-
-  test('non-tty without flags → refusal of the STEP (with the flag recipe), not of onboard', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    writeRuntimeManifest({ runtime: 'telegram' }, { env })
-    const r = await onboardTelegramStep({ env, isTty: false })
-    expect(r.state).toBe('refused-non-tty')
-    expect(r.detail).toContain('--telegram-human')
-  })
-
-  test('tty prompt path: answers flow in; empty answer → soft refusal', async () => {
-    const root = mkTmp()
-    const { dir, hook } = stubBins('telegram-runtime')
-    const env = envFor(root, dir)
-    writeRuntimeManifest({ runtime: 'telegram', selfConfig: hook }, { env })
-    const answers = ['leo', '42']
-    const r = await onboardTelegramStep({ env, isTty: true, ask: async () => answers.shift() ?? '' })
-    expect(r.state).toBe('created')
-    expect(r.personality).toBe('leo')
-    // empty answer → not now
-    const env2 = envFor(mkTmp())
-    writeRuntimeManifest({ runtime: 'telegram' }, { env: env2 })
-    const r2 = await onboardTelegramStep({ env: env2, isTty: true, ask: async () => '' })
-    expect(r2.state).toBe('refused-non-tty')
-  })
-
-  test('invalid explicit flags → invalid-input (hard): bad name / non-digit user id', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    writeRuntimeManifest({ runtime: 'telegram' }, { env })
-    expect((await onboardTelegramStep({ human: '!!!', userId: '42', env })).state).toBe('invalid-input')
-    const r = await onboardTelegramStep({ human: 'leo', userId: 'abc', env })
-    expect(r.state).toBe('invalid-input')
-    expect(r.detail).toContain('@userinfobot')
-  })
-
-  test('package unavailable → soft skip (step), with the install-later recipe', async () => {
-    const env = envFor(mkTmp())
-    const r = await onboardTelegramStep({
-      human: 'leo',
-      userId: '42',
-      env,
-      runNpx: () => ({ ok: false, detail: 'npm ERR 404' }),
-    })
-    expect(r.state).toBe('skipped-unavailable')
-    expect(r.detail).toContain('install-runtime telegram')
-  })
-
-  test('findNaturalPeer: null on empty/no registry, found when present', async () => {
-    const env = envFor(mkTmp())
-    expect(findNaturalPeer(env)).toBeNull()
-    await upsertPeer({ personality: 'h', runtime: 'telegram', cwd: '/tmp/h', intelligence: 'natural' }, { env })
-    expect(findNaturalPeer(env)).toBe('h')
-  })
-})