@agfpd/iapeer 0.2.77 → 0.2.79

package/src/create/create.test.ts

@@ -1,143 +0,0 @@
-// createPeer — cwd-independent peer creation: resolve a location (default
-// ~/.iapeer/peers/<p> or --path), scaffold the folder (no-clobber), init it. All
-// writes go under IAPEER_ROOT / IAPEER_LAUNCHAGENTS_DIR temp dirs; IAPEER_TEST_SANDBOX
-// (set by the test script) makes launchctlBootstrap a no-op (skipped-sandbox), so the
-// suite never loads a real launchd job.
-
-import { afterEach, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { createPeer } from './index.ts'
-import { defaultPeerCwd, peerProfilePath } from '../storage/index.ts'
-import { readPeerProfile, writePeerProfileAtomic } from '../identity/index.ts'
-import { findPeer, readPeersIndex } from '../registry/index.ts'
-import { isFoundationOwnedPlist, launchdPlistPath } from '../launch/index.ts'
-
-const roots: string[] = []
-function mkTmp(): string {
-  const d = mkdtempSync(join(tmpdir(), 'iapeer-create-'))
-  roots.push(d)
-  return d
-}
-afterEach(() => {
-  while (roots.length) rmSync(roots.pop()!, { recursive: true, force: true })
-})
-
-function fakeBin(name: string): { dir: string; bin: string } {
-  const dir = mkTmp()
-  const bin = join(dir, name)
-  writeFileSync(bin, '#!/bin/sh\nexec sleep 1\n', { mode: 0o755 })
-  return { dir, bin }
-}
-function envFor(root: string, path?: string): NodeJS.ProcessEnv {
-  return {
-    IAPEER_ROOT: join(root, 'iapeer'),
-    IAPEER_LAUNCHAGENTS_DIR: join(root, 'LA'),
-    IAPEER_TEST_SANDBOX: '1', // never load a real launchd job from the suite
-    HOME: root,
-    ...(path ? { PATH: path } : {}),
-  } as NodeJS.ProcessEnv
-}
-
-describe('createPeer — default location', () => {
-  test('claude peer lands at ~/.iapeer/peers/<p>, scaffolds folder + profile + registry + .mcp.json', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    const r = await createPeer({ personality: 'worker', runtime: 'claude', env })
-
-    expect(r.location).toBe(defaultPeerCwd('worker', { env }))
-    expect(r.createdFolder).toBe(true)
-    expect(r.runtime).toBe('claude')
-    // folder + profile
-    expect(existsSync(peerProfilePath(r.location))).toBe(true)
-    expect(readPeerProfile(r.location)!.personality).toBe('worker')
-    // registry
-    expect(findPeer(readPeersIndex({ env }), 'worker')?.cwd).toBe(r.location)
-    // claude transport wiring
-    expect(r.mcpConfigPaths.length).toBe(1)
-    expect(existsSync(join(r.location, '.mcp.json'))).toBe(true)
-    // agentic → no plist, no bootstrap
-    expect(r.plistPath).toBeUndefined()
-    expect(r.bootstrapped).toBeUndefined()
-  })
-
-  test('personality is normalized; default home derives from the normalized name', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    const r = await createPeer({ personality: 'Maria', runtime: 'claude', env })
-    expect(r.personality).toBe('maria')
-    expect(r.location).toBe(defaultPeerCwd('maria', { env }))
-  })
-})
-
-describe('createPeer — infra (telegram human / notifier function): plist + auto-bootstrap', () => {
-  test('telegram peer: natural intelligence, foundation-owned plist, bootstrap skipped under sandbox', async () => {
-    const root = mkTmp()
-    const { dir: bindir, bin } = fakeBin('telegram-runtime')
-    const env = envFor(root, bindir)
-
-    const r = await createPeer({ personality: 'maria', runtime: 'telegram', env })
-
-    expect(r.runtime).toBe('telegram')
-    expect(r.intelligence).toBe('natural') // telegram zone default (human)
-    const plist = launchdPlistPath('maria', env)
-    expect(existsSync(plist)).toBe(true)
-    expect(isFoundationOwnedPlist(plist)).toBe(true)
-    expect(readFileSync(plist, 'utf8')).toContain(`<string>${bin}</string>`)
-    // AUTO-bootstrap attempted, but the sandbox guard makes it a no-op
-    expect(r.bootstrapped?.state).toBe('skipped-sandbox')
-    // router runtime → no MCP client config
-    expect(r.mcpConfigPaths.length).toBe(0)
-    expect(r.codexMcpConfigPath).toBeUndefined()
-  })
-
-  test('two telegram humans → two distinct plists (1 always-on peer = 1 plist)', async () => {
-    const root = mkTmp()
-    const { dir: bindir } = fakeBin('telegram-runtime')
-    const env = envFor(root, bindir)
-
-    await createPeer({ personality: 'maria', runtime: 'telegram', env })
-    await createPeer({ personality: 'pavel', runtime: 'telegram', env })
-
-    expect(existsSync(launchdPlistPath('maria', env))).toBe(true)
-    expect(existsSync(launchdPlistPath('pavel', env))).toBe(true)
-    expect(findPeer(readPeersIndex({ env }), 'maria')).not.toBeNull()
-    expect(findPeer(readPeersIndex({ env }), 'pavel')).not.toBeNull()
-  })
-
-  test('re-create of the same infra peer is idempotent (no duplicate, no clobber)', async () => {
-    const root = mkTmp()
-    const { dir: bindir } = fakeBin('telegram-runtime')
-    const env = envFor(root, bindir)
-
-    await createPeer({ personality: 'maria', runtime: 'telegram', env })
-    const r2 = await createPeer({ personality: 'maria', runtime: 'telegram', env })
-
-    expect(r2.createdFolder).toBe(false)
-    expect(readPeersIndex({ env }).peers.filter(p => p.personality === 'maria').length).toBe(1)
-  })
-})
-
-describe('createPeer — location resolution + no-clobber', () => {
-  test('--path overrides the default home', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    const custom = join(mkTmp(), 'custom-peer')
-    const r = await createPeer({ personality: 'worker', runtime: 'claude', path: custom, env })
-    expect(r.location).toBe(custom)
-    expect(existsSync(peerProfilePath(custom))).toBe(true)
-  })
-
-  test('refuses to create into a folder already holding a DIFFERENT peer', async () => {
-    const root = mkTmp()
-    const env = envFor(root)
-    const dir = join(mkTmp(), 'occupied')
-    // Seed a different peer's profile in the target.
-    writePeerProfileAtomic(dir, { personality: 'boris', runtime: 'claude', runtimes: ['claude'] })
-
-    await expect(createPeer({ personality: 'maria', runtime: 'claude', path: dir, env })).rejects.toThrow(
-      /already holds peer "boris"/,
-    )
-  })
-})

package/src/daemon/daemon-http.test.ts

@@ -1,114 +0,0 @@
-// HTTP integration test: the daemon driven by a REAL MCP client
-// (@modelcontextprotocol/sdk Client + StreamableHTTPClientTransport) over a TCP
-// loopback listener. Because both ends use the canonical SDK transport, this is
-// the on-wire equivalent of a real claude/codex http MCP client connecting — it
-// is what makes the hand-rolled-handshake H2 risk moot.
-//
-// No delivery to a live peer here (boris/arthur are only used as CALLERS; the
-// only send_to_peer target is the offline fixture peer), so the test has no side
-// effects on the live fleet.
-
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { mkdtempSync, rmSync, statSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
-import { CALLER_HEADER, startDaemon, type DaemonHandle } from './index.ts'
-
-let root: string
-let daemon: DaemonHandle
-const prevRoot = process.env.IAPEER_ROOT
-
-const FIXTURE = {
-  version: 2,
-  peers: [
-    { personality: 'boris', runtime: 'claude', runtimes: ['claude'], description: 'Напарник', intelligence: 'artificial', cwd: '/tmp/boris' },
-    { personality: 'arthur', runtime: 'telegram', runtimes: ['telegram', 'claude'], description: 'Артур', intelligence: 'human', cwd: '/tmp/arthur' },
-    { personality: 'offlinepeer', runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial', cwd: '/tmp/offlinepeer' },
-  ],
-}
-
-beforeAll(async () => {
-  root = mkdtempSync(join(tmpdir(), 'iapeer-http-'))
-  writeFileSync(join(root, 'peers-profiles.json'), JSON.stringify(FIXTURE))
-  process.env.IAPEER_ROOT = root
-  daemon = await startDaemon({ port: 0, host: '127.0.0.1' }) // TCP loopback for real http MCP clients
-})
-afterAll(async () => {
-  await daemon.close()
-  if (prevRoot === undefined) delete process.env.IAPEER_ROOT
-  else process.env.IAPEER_ROOT = prevRoot
-  rmSync(root, { recursive: true, force: true })
-})
-
-async function connect(identity?: string): Promise<Client> {
-  const headers: Record<string, string> = {}
-  if (identity) headers['X-IAPeer-Identity'] = identity
-  const transport = new StreamableHTTPClientTransport(new URL(daemon.url!), { requestInit: { headers } })
-  const client = new Client({ name: 'iapeer-test-client', version: '0.0.0' })
-  await client.connect(transport)
-  return client
-}
-
-describe('daemon over SDK StreamableHTTP (real MCP client)', () => {
-  test('a real SDK client completes the initialize handshake and lists the tool-set', async () => {
-    const client = await connect('claude-boris')
-    const { tools } = await client.listTools()
-    // ONLY send_to_peer — list_online_peers is deprecated by contract (no extra
-    // agent-facing tool; liveness is the CLI `list` verb).
-    expect(tools.map(t => t.name).sort()).toEqual(['send_to_peer'])
-    await client.close()
-  })
-
-  test('PER-REQUEST identity: the header decides the caller, not a per-process default', async () => {
-    // Caller resolution runs BEFORE tool dispatch, so send_to_peer exercises it.
-    // A KNOWN caller (boris) is accepted → routing proceeds and fails with the
-    // OFFLINE error (not an identity rejection): the target offlinepeer is dead.
-    const ok = await connect('claude-boris')
-    const okRes = await ok.callTool({ name: 'send_to_peer', arguments: { personality: 'offlinepeer', message: 'hi' } })
-    expect(okRes.isError).toBe(true)
-    expect((okRes.content as any)[0].text).not.toMatch(/unknown caller/)
-    expect((okRes.content as any)[0].text).toMatch(/offline/)
-    await ok.close()
-
-    // a different client with an UNKNOWN caller header → rejected at identity
-    const ghost = await connect('claude-ghost')
-    const ghostRes = await ghost.callTool({ name: 'send_to_peer', arguments: { personality: 'offlinepeer', message: 'hi' } })
-    expect(ghostRes.isError).toBe(true)
-    expect((ghostRes.content as any)[0].text).toMatch(/unknown caller/)
-    await ghost.close()
-  })
-
-  test('CallTool WITHOUT identity header → rejected (no silent default)', async () => {
-    const client = await connect(undefined)
-    const res = await client.callTool({ name: 'send_to_peer', arguments: { personality: 'offlinepeer', message: 'hi' } })
-    expect(res.isError).toBe(true)
-    expect((res.content as any)[0].text).toMatch(new RegExp(CALLER_HEADER))
-    await client.close()
-  })
-
-  test('send_to_peer to an offline fixture peer → explicit offline error (no wake in Ф1)', async () => {
-    const client = await connect('claude-boris')
-    const res = await client.callTool({
-      name: 'send_to_peer',
-      arguments: { personality: 'offlinepeer', message: 'hi' },
-    })
-    expect(res.isError).toBe(true)
-    expect((res.content as any)[0].text).toMatch(/offline/)
-    await client.close()
-  })
-})
-
-describe('daemon over unix socket (H8 base)', () => {
-  test('binds a 0600 unix socket', async () => {
-    const sockRoot = mkdtempSync(join(tmpdir(), 'iapeer-sock-'))
-    const h = await startDaemon({ socketPath: join(sockRoot, 'router.sock') })
-    try {
-      expect((statSync(h.socketPath!).mode & 0o777).toString(8)).toBe('600')
-    } finally {
-      await h.close()
-      rmSync(sockRoot, { recursive: true, force: true })
-    }
-  })
-})

package/src/daemon/daemon.test.ts

@@ -1,267 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import {
-  CALLER_HEADER,
-  callTool,
-  listTools,
-  parseCallerHeader,
-  resolveCallerFromHeader,
-} from './index.ts'
-import { readPeersIndex } from '../registry/index.ts'
-
-// Point the registry at a fixture root via IAPEER_ROOT so these unit tests are
-// deterministic and never touch the live host registry.
-let root: string
-const prevRoot = process.env.IAPEER_ROOT
-
-const FIXTURE = {
-  version: 2,
-  peers: [
-    { personality: 'arthur', runtime: 'telegram', runtimes: ['telegram', 'claude'], description: 'Артур', intelligence: 'human', cwd: '/Users/macmini/Peers/arthur', interfaces: { telegram: { user_id: '409502965' } } },
-    { personality: 'boris', runtime: 'claude', runtimes: ['claude'], description: 'Напарник', intelligence: 'artificial', cwd: '/Users/macmini/Peers/boris' },
-    { personality: 'offlinepeer', runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial', cwd: '/tmp/offlinepeer' },
-  ],
-}
-
-beforeAll(() => {
-  root = mkdtempSync(join(tmpdir(), 'iapeer-daemon-'))
-  writeFileSync(join(root, 'peers-profiles.json'), JSON.stringify(FIXTURE))
-  process.env.IAPEER_ROOT = root
-})
-afterAll(() => {
-  if (prevRoot === undefined) delete process.env.IAPEER_ROOT
-  else process.env.IAPEER_ROOT = prevRoot
-  rmSync(root, { recursive: true, force: true })
-})
-
-describe('caller identity from header', () => {
-  test('parses <runtime>-<personality>', () => {
-    expect(parseCallerHeader('claude-boris')).toEqual({ personality: 'boris', runtime: 'claude' })
-    expect(parseCallerHeader('telegram-arthur')).toEqual({ personality: 'arthur', runtime: 'telegram' })
-    expect(parseCallerHeader('claude-company-checker')).toEqual({ personality: 'company-checker', runtime: 'claude' })
-  })
-
-  test('rejects empty / malformed header', () => {
-    expect(parseCallerHeader(undefined)).toBeNull()
-    expect(parseCallerHeader('')).toBeNull()
-    expect(parseCallerHeader('noseparator')).toBeNull()
-  })
-
-  test('PER-REQUEST: two different headers resolve to two different callers', () => {
-    const index = readPeersIndex()
-    const a = resolveCallerFromHeader('claude-boris', index)
-    const b = resolveCallerFromHeader('telegram-arthur', index)
-    expect(a.address).toBe('claude-boris')
-    expect(b.address).toBe('telegram-arthur')
-    // read-compat carried through: arthur's legacy 'human' resolves to 'natural'
-    expect(b.intelligence).toBe('natural')
-  })
-
-  test('missing header → throws (mentions the header name)', () => {
-    expect(() => resolveCallerFromHeader(undefined, readPeersIndex())).toThrow(new RegExp(CALLER_HEADER))
-  })
-
-  test('unknown caller → throws (spoofing guard)', () => {
-    expect(() => resolveCallerFromHeader('claude-ghost', readPeersIndex())).toThrow(/unknown caller/)
-  })
-
-  test('undeclared runtime for a known caller → throws', () => {
-    expect(() => resolveCallerFromHeader('codex-boris', readPeersIndex())).toThrow(/not declared/)
-  })
-})
-
-describe('listTools', () => {
-  test('serves ONLY send_to_peer (list_online_peers deprecated) with alwaysLoad meta and NO embedded roster', () => {
-    const tools = listTools() as any[]
-    expect(tools.map(t => t.name).sort()).toEqual(['send_to_peer'])
-    expect(tools.every(t => t._meta['anthropic/alwaysLoad'] === true)).toBe(true)
-    const sendTool = tools.find(t => t.name === 'send_to_peer')
-    // Regression guard: the peer roster lives ONLY in the system prompt
-    // (composeSystemPrompt → "## Known peers"), NEVER in the tool description —
-    // embedding it here duplicated the list into every agent's context per turn.
-    expect(sendTool.description).not.toMatch(/Known peers/)
-    expect(sendTool.description).not.toContain('arthur')
-    expect(sendTool.description).not.toMatch(/Runtimes:/)
-    // Purpose + parameter semantics stay.
-    expect(sendTool.description).toContain('Send a message to a known iapeer peer')
-    expect(sendTool.description).toContain('wakes it and delivers there')
-    expect(sendTool.description).toContain('parallel to the default runtime')
-    expect(sendTool.inputSchema.properties.runtime.description).toContain('wakes it warm-on-demand')
-    expect(sendTool.inputSchema.properties.runtime.description).toContain('parallel session')
-  })
-})
-
-describe('callTool (no wake passed → Ф1 offline behaviour, never spawns)', () => {
-  test('send_to_peer to an OFFLINE peer → explicit peer-offline error', async () => {
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    const r = await callTool(caller, 'send_to_peer', { personality: 'offlinepeer', message: 'hi' })
-    expect(r.isError).toBe(true)
-    expect(r.content[0].text).toMatch(/offline/)
-  })
-
-  test('send_to_peer to a peer NOT in the registry → not-delivered error', async () => {
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    const r = await callTool(caller, 'send_to_peer', { personality: 'nobody', message: 'hi' })
-    expect(r.isError).toBe(true)
-    expect(r.content[0].text).toMatch(/not in the iapeer peers index/)
-  })
-
-  test('unknown tool → error', async () => {
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    expect((await callTool(caller, 'bogus', {})).isError).toBe(true)
-  })
-})
-
-describe('per-delivery outcome log (Ф-#8a — delivery.log)', () => {
-  test('with deliveryLogDir wired: ONE logfmt outcome line per attempt, metadata only', async () => {
-    const logDir = join(root, 'logs', 'iapeer')
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    await callTool(caller, 'send_to_peer', { personality: 'offlinepeer', message: 'hi' }, { deliveryLogDir: logDir })
-    await callTool(
-      caller,
-      'send_to_peer',
-      { personality: 'nobody', message: 'hello there', topic: 'probe topic' },
-      { deliveryLogDir: logDir },
-    )
-    const lines = readFileSync(join(logDir, 'delivery.log'), 'utf8').trim().split('\n')
-    expect(lines.length).toBe(2)
-    // attempt 1: known-but-offline peer (no wake wired → Ф1 explicit offline)
-    expect(lines[0]).toContain('ev=delivery')
-    expect(lines[0]).toContain('caller=claude-boris')
-    expect(lines[0]).toContain('to=offlinepeer')
-    expect(lines[0]).toContain('ok=false')
-    expect(lines[0]).toMatch(/err=".*offline.*"/)
-    expect(lines[0]).toContain('len=2') // body length, NEVER the body itself
-    expect(lines[0]).not.toContain('hi"') // the message text must not leak
-    // attempt 2: unknown peer — validation failures are recorded too
-    expect(lines[1]).toContain('to=nobody')
-    expect(lines[1]).toContain('ok=false')
-    expect(lines[1]).toContain('topic="probe topic"')
-    expect(lines[1]).toContain('len=11')
-  })
-
-  test('without deliveryLogDir (default): nothing is written — library/test daemons stay hermetic', async () => {
-    const probeDir = join(root, 'logs', 'unwired')
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    await callTool(caller, 'send_to_peer', { personality: 'offlinepeer', message: 'hi' })
-    expect(existsSync(join(probeDir, 'delivery.log'))).toBe(false)
-  })
-})
-
-describe('onDelivered hook (M2 arm-on-outbound seam)', () => {
-  test('NOT fired on a FAILED delivery — a worker whose reply did not land must not be armed', async () => {
-    const fired: string[] = []
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    // offline target, no wake → routeSend fails → hook must stay silent
-    const r = await callTool(
-      caller,
-      'send_to_peer',
-      { personality: 'offlinepeer', message: 'hi' },
-      { onDelivered: c => fired.push(c.address) },
-    )
-    expect(r.isError).toBe(true)
-    expect(fired).toEqual([])
-  })
-
-  test('a throwing hook never fails the tool call (fail-safe)', async () => {
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    // even on the error path nothing throws; the ok-path guard is the same try/catch
-    const r = await callTool(
-      caller,
-      'send_to_peer',
-      { personality: 'offlinepeer', message: 'hi' },
-      {
-        onDelivered: () => {
-          throw new Error('hook boom')
-        },
-      },
-    )
-    expect(r.isError).toBe(true) // the routeSend offline error, NOT the hook's
-    expect(r.content[0].text).toMatch(/offline/)
-  })
-})
-
-describe('ephemeral serial-queue seam (M3)', () => {
-  test('ephemeral TARGET → deliver() handles it (no live/miss routing); queued result + delivery.log queued/qd', async () => {
-    const logDir = join(root, 'logs', 'm3')
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    const delivered: string[] = []
-    const r = await callTool(
-      caller,
-      'send_to_peer',
-      { personality: 'offlinepeer', message: 'job for the worker', topic: 'job-1' },
-      {
-        deliveryLogDir: logDir,
-        ephemeral: {
-          isEphemeral: cwd => {
-            delivered.push(`checked:${cwd}`)
-            return true // offlinepeer plays an ephemeral worker
-          },
-          deliver: async ({ peer, envelope, topic }) => {
-            delivered.push(`deliver:${peer.personality}:${topic}`)
-            expect(envelope).toContain('job for the worker') // the routed envelope, not the raw body
-            return {
-              ok: true,
-              value: {
-                ok: true as const,
-                delivered_to: { personality: peer.personality, runtime: 'claude' },
-                woke: false,
-                queued: true,
-                queuedBy: 'ephemeral',
-                queueDepth: 2,
-                ts: 'now',
-              },
-            }
-          },
-        },
-      },
-    )
-    expect(r.isError).toBeUndefined()
-    expect(delivered).toEqual(['checked:/tmp/offlinepeer', 'deliver:offlinepeer:job-1'])
-    const line = readFileSync(join(logDir, 'delivery.log'), 'utf8').trim()
-    expect(line).toContain('queued=true')
-    expect(line).toContain('qkind=ephemeral')
-    expect(line).toContain('qd=2')
-    expect(line).toContain('ok=true')
-  })
-
-  test('ephemeral self-send is refused up front (a worker enqueueing itself would deadlock its reap)', async () => {
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    const r = await callTool(
-      caller,
-      'send_to_peer',
-      { personality: 'boris', message: 'to myself' },
-      {
-        ephemeral: {
-          isEphemeral: () => true,
-          deliver: async () => {
-            throw new Error('must not be reached')
-          },
-        },
-      },
-    )
-    expect(r.isError).toBe(true)
-    expect(r.content[0].text).toMatch(/cannot send to self/)
-  })
-
-  test('non-ephemeral target ignores the seam (normal offline path)', async () => {
-    const caller = resolveCallerFromHeader('claude-boris', readPeersIndex())
-    const r = await callTool(
-      caller,
-      'send_to_peer',
-      { personality: 'offlinepeer', message: 'hi' },
-      {
-        ephemeral: {
-          isEphemeral: () => false,
-          deliver: async () => {
-            throw new Error('must not be reached')
-          },
-        },
-      },
-    )
-    expect(r.isError).toBe(true)
-    expect(r.content[0].text).toMatch(/offline/) // took the ordinary miss path
-  })
-})