@agfpd/iapeer 0.1.0

package/src/core/socket.ts

@@ -0,0 +1,63 @@
+// Socket-path convention. Consolidated from inter-agent-protocol/src/lib/socket-parser.ts (wins).
+// One builder/parser for /tmp/tmux-iap-<runtime>-<personality>.sock and <runtime>-<personality>.
+
+import { basename, join } from 'path'
+import {
+  DEFAULT_SOCK_DIR,
+  NAME_RE_SOURCE,
+  RUNTIME_RE_SOURCE,
+  isTmuxRuntime,
+  isValidName,
+  type TmuxRuntime,
+} from './constants.ts'
+
+export interface ProcessAddress {
+  runtime: TmuxRuntime
+  personality: string
+  address: `${TmuxRuntime}-${string}`
+}
+
+const socketNameRe = new RegExp(
+  `^tmux-iap-(${RUNTIME_RE_SOURCE.slice(1, -1)})-(${NAME_RE_SOURCE.slice(1, -1)})\\.sock$`,
+)
+
+export function parseSessionName(value: string): ProcessAddress | null {
+  const split = value.indexOf('-')
+  if (split <= 0) return null
+  const runtime = value.slice(0, split)
+  const personality = value.slice(split + 1)
+  if (!isTmuxRuntime(runtime) || !isValidName(personality)) return null
+  return {
+    runtime,
+    personality,
+    address: value as `${TmuxRuntime}-${string}`,
+  }
+}
+
+export function parseSocketPath(path: string): ProcessAddress | null {
+  const m = basename(path).match(socketNameRe)
+  if (!m) return null
+  const runtime = m[1]
+  const personality = m[2]
+  if (!isTmuxRuntime(runtime) || !isValidName(personality)) return null
+  return {
+    runtime,
+    personality,
+    address: `${runtime}-${personality}` as const,
+  }
+}
+
+export function buildProcessAddress(
+  runtime: TmuxRuntime,
+  personality: string,
+): `${TmuxRuntime}-${string}` {
+  return `${runtime}-${personality}` as const
+}
+
+export function buildSocketPath(
+  runtime: TmuxRuntime,
+  personality: string,
+  sockDir = DEFAULT_SOCK_DIR,
+): string {
+  return join(sockDir, `tmux-iap-${runtime}-${personality}.sock`)
+}

package/src/create/create.test.ts

@@ -0,0 +1,143 @@
+// 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/create/index.ts

@@ -0,0 +1,178 @@
+// create — the cwd-INDEPENDENT peer-creation verb (`iapeer create <personality>
+// [--runtime] [--path]`, contract Фаза §1 / Примитивы). Where `init` provisions the
+// CURRENT folder (cwd-dependent, for an implementer working IN a repo), `create`
+// RESOLVES a location for a brand-new peer, scaffolds the folder, then inits it —
+// from anywhere, no `cd` required.
+//
+// LOCATION: --path wins; otherwise the foundation-owned default home
+// ~/.iapeer/peers/<personality> (collision-free, unlike the organic ~/Peers the
+// legacy fleet grew in — existing ~/Peers/* peers are grandfathered, NOT migrated).
+//
+// NO-CLOBBER: making the folder is mkdir-recursive (never deletes); init is
+// idempotent (profile kept, .mcp.json merged, doctrine never overwritten). The one
+// hard refusal: a target that already holds a DIFFERENT peer's profile — creating
+// "maria" into a folder that is already "boris" would either silently adopt boris or
+// split an identity, so it fails loudly instead.
+//
+// INFRA (telegram human via operator-add / notifier function via a declared set):
+// runtime=telegram|notifier → provision installs the always-on plist and (default)
+// AUTO-bootstraps it. "1 always-on infra peer = 1 plist", idempotent (re-create of
+// the same peer does not duplicate or clobber — installAlwaysOnPlist's sentinel guard
+// allows re-writing only OUR own plist).
+
+import { existsSync, mkdirSync } from 'fs'
+import { resolve } from 'path'
+import { isValidName, normalizeNameCandidate, type Intelligence, type Runtime } from '../core/constants.ts'
+import { IapError } from '../core/errors.ts'
+import { defaultPeerCwd, ensureGlobalIapScaffold } from '../storage/index.ts'
+import { readPeerProfile } from '../identity/index.ts'
+import { initPeer, type InitPeerResult } from '../init/index.ts'
+
+export interface CreatePeerOptions {
+  /** The peer's personality (REQUIRED; validated/normalized). Drives the default
+   *  location (~/.iapeer/peers/<personality>) and the registry/profile identity. */
+  personality: string
+  /** Primary runtime (default: claude). claude/codex → agentic; telegram/notifier →
+   *  infra (always-on plist + auto-bootstrap). */
+  runtime?: Runtime
+  /** Explicit location. Default: ~/.iapeer/peers/<personality> (IAPEER_ROOT-aware). */
+  path?: string
+  description?: string
+  intelligence?: Intelligence
+  /** Infra runtime launcher (abs path / PATH name) baked into the always-on plist. */
+  runtimeBin?: string
+  /** AUTO-bootstrap a freshly-provisioned infra plist (default true; infra only). */
+  bootstrap?: boolean
+  env?: NodeJS.ProcessEnv
+  warn?: (message: string) => void
+}
+
+export interface CreatePeerResult extends InitPeerResult {
+  /** The resolved peer cwd (default home or --path). */
+  location: string
+  /** True when this run created the folder (false when it already existed). */
+  createdFolder: boolean
+}
+
+/**
+ * Create a peer from anywhere: resolve a location, scaffold the folder (no-clobber),
+ * then run init in it (identity + registry + per-runtime MCP / infra plist + doctrine,
+ * with auto-bootstrap for infra). Returns the init result plus the resolved location.
+ */
+export async function createPeer(opts: CreatePeerOptions): Promise<CreatePeerResult> {
+  const env = opts.env ?? process.env
+  const personality = normalizeNameCandidate(opts.personality)
+  if (!isValidName(personality)) {
+    throw new IapError(
+      `invalid personality "${opts.personality}" — must normalize to /^[a-z][a-z0-9-]{0,31}$/`,
+    )
+  }
+
+  // Ensure the global tree (incl. ~/.iapeer/peers/) exists before landing a peer there.
+  ensureGlobalIapScaffold({ env })
+
+  const location = opts.path ? resolve(opts.path) : defaultPeerCwd(personality, { env })
+
+  // NO-CLOBBER refusal: a target that already holds a DIFFERENT peer's profile.
+  const existing = existsSync(location) ? readPeerProfile(location) : null
+  if (existing && existing.personality !== personality) {
+    throw new IapError(
+      `refusing to create peer "${personality}" at ${location}: it already holds peer "${existing.personality}" ` +
+        `(.iapeer/peer-profile.json) — choose another --path or personality`,
+    )
+  }
+
+  const createdFolder = !existsSync(location)
+  mkdirSync(location, { recursive: true }) // recursive mkdir never deletes existing content
+
+  // create is cwd-INDEPENDENT with an EXPLICIT personality, so the ambient session's
+  // identity must not govern it. When `iapeer create` is run from INSIDE a peer
+  // session (an orchestrator agent provisioning another peer — a real flow), the
+  // inherited PEER_PERSONALITY/PEER_IDENTITY/PEER_RUNTIME would trip the identity gate
+  // (it refuses a mismatch). The explicit personality is authoritative here, so strip
+  // those three ABI vars from the env passed down. (`init`, cwd-dependent, keeps the
+  // gate — you init your OWN folder, the ambient identity SHOULD match.) IAPEER_ROOT
+  // and the rest of the env are preserved.
+  const childEnv: NodeJS.ProcessEnv = { ...env }
+  delete childEnv.PEER_PERSONALITY
+  delete childEnv.PEER_IDENTITY
+  delete childEnv.PEER_RUNTIME
+
+  const result = await initPeer({
+    cwd: location,
+    runtime: opts.runtime,
+    personality,
+    description: opts.description,
+    intelligence: opts.intelligence,
+    runtimeBin: opts.runtimeBin,
+    bootstrap: opts.bootstrap,
+    env: childEnv,
+    warn: opts.warn,
+  })
+
+  return { ...result, location, createdFolder }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// CLI — `iapeer create <personality> …` / `bun src/create/index.ts <personality> …`
+// ─────────────────────────────────────────────────────────────────────────────
+
+if (import.meta.main) {
+  const argv = process.argv.slice(2)
+  const positionals: string[] = []
+  const flags: Record<string, string | true> = {}
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=')
+      if (eq > 2) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1)
+        continue
+      }
+      const next = argv[i + 1]
+      if (next === undefined || next.startsWith('--')) flags[a.slice(2)] = true
+      else flags[a.slice(2)] = argv[++i]
+    } else {
+      positionals.push(a)
+    }
+  }
+  const personality = positionals[0]
+  if (!personality) {
+    process.stderr.write(
+      'usage: create <personality> [--runtime r] [--path dir] [--description d] [--bin abs] [--intelligence i] [--no-bootstrap]\n',
+    )
+    process.exit(2)
+  }
+  createPeer({
+    personality,
+    runtime: typeof flags.runtime === 'string' ? (flags.runtime as Runtime) : undefined,
+    path: typeof flags.path === 'string' ? flags.path : undefined,
+    description: typeof flags.description === 'string' ? flags.description : undefined,
+    intelligence: typeof flags.intelligence === 'string' ? (flags.intelligence as Intelligence) : undefined,
+    runtimeBin: typeof flags.bin === 'string' ? flags.bin : undefined,
+    bootstrap: flags['no-bootstrap'] === true ? false : undefined,
+    warn: m => process.stderr.write(`warn: ${m}\n`),
+  })
+    .then(r => {
+      process.stdout.write(
+        `created peer "${r.personality}" (${r.runtime}, ${r.intelligence}) at ${r.location}` +
+          `${r.createdFolder ? ' (new folder)' : ' (existing folder)'}\n` +
+          `  profile:  ${r.profilePath}\n` +
+          `  registry: peers-profiles.json updated\n` +
+          (r.mcpConfigPaths.length
+            ? `  mcp:      ${r.mcpConfigPaths.join(', ')} → ${r.daemonUrl}\n`
+            : r.codexMcpConfigPath
+              ? `  mcp:      ${r.codexMcpConfigPath} (codex)\n`
+              : '  mcp:      (none — infra/router runtime)\n') +
+          (r.plistPath ? `  plist:    ${r.plistPath}\n` : '') +
+          (r.selfConfig ? `  selfcfg:  ${r.selfConfig.state}${r.selfConfig.detail ? ` — ${r.selfConfig.detail}` : ''}\n` : '') +
+          (r.bootstrapped ? `  bootstrap:${r.bootstrapped.state}${r.bootstrapped.detail ? ` — ${r.bootstrapped.detail}` : ''}\n` : '') +
+          `  doctrine: ${r.doctrinePath}${r.doctrineCreated ? ' (template created — fill it in)' : ' (kept)'}\n`,
+      )
+      process.exit(0)
+    })
+    .catch(e => {
+      process.stderr.write(`create failed: ${e instanceof Error ? e.message : String(e)}\n`)
+      process.exit(1)
+    })
+}

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

@@ -0,0 +1,114 @@
+// 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

@@ -0,0 +1,103 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { mkdtempSync, 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 roster', () => {
+    const tools = listTools(readPeersIndex()) as any[]
+    expect(tools.map(t => t.name).sort()).toEqual(['send_to_peer'])
+    expect(tools.every(t => t._meta['anthropic/alwaysLoad'] === true)).toBe(true)
+    expect(tools.find(t => t.name === 'send_to_peer').description).toContain('arthur')
+  })
+})
+
+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)
+  })
+})