@agfpd/iapeer 0.2.38 → 0.2.39

package/package.json

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

package/src/transport/index.ts

@@ -487,6 +487,46 @@ function validateAttachments(value: readonly string[] = []): Result<string[]> {
   return ok(out)
 }
 
+// ─── Telegram-domain sender policy (defect track 11.06, sanctioned by Артур) ─
+
+/** A SENDER face in the telegram domain: a non-empty interfaces.telegram.bot (the
+ *  bot machine-key) in the peer's registry passport. Deliberately bot-ONLY, not
+ *  bot|user_id — the bridge picks the SENDING bot from the sender's bot key
+ *  (owner fact, telegram-runtime сверка 11.06): a user_id grants a receive/operator
+ *  identity but no ability to send, so a user_id-only sender passing the guard
+ *  would still die at the bridge — a late asynchronous failure where the guard
+ *  exists to give a synchronous one. The guard passes exactly what the bridge can
+ *  deliver. */
+export function hasTelegramPresence(record: PeerRecord): boolean {
+  const tg = record.interfaces?.telegram
+  if (!tg || typeof tg !== 'object' || Array.isArray(tg)) return false
+  const t = tg as Record<string, unknown>
+  return typeof t.bot === 'string' && t.bot.trim() !== ''
+}
+
+/** Sender policy for the telegram domain: a peer with NO declared telegram presence
+ *  must not write into it — the recipient (a human in Telegram) would face a message
+ *  from a peer that has no telegram face (identity confusion: who writes, by what
+ *  right?). Bot channel = declared presence; no presence — no right to the domain.
+ *  Enforced at the ROUTER, not the bridge: the refusal is synchronous and lands in
+ *  the sender's tool result; a bridge-side check would fire AFTER the router's
+ *  ok:true — a false-OK + silent loss, the class this contract forbids. Applied to
+ *  the INTENDED channel (override / target default — before any wake side-effect,
+ *  since a wake delivers the envelope as the boot first-message) AND to the RESOLVED
+ *  channel at both delivery points (the only-live-session fallback can land on
+ *  telegram without either). */
+function telegramSenderGuard(
+  caller: ResolvedCaller,
+  targetRuntime: string,
+  targetPersonality: string,
+): Result<void> {
+  if (targetRuntime !== 'telegram') return ok(undefined)
+  if (hasTelegramPresence(caller.record)) return ok(undefined)
+  return err(
+    `telegram policy: sender "${caller.personality}" has no telegram face (no interfaces.telegram.bot in its passport) — message to "${targetPersonality}" NOT delivered; route via a telegram-faced peer (e.g. boris) or provision a bot for this sender`,
+  )
+}
+
 /**
  * Route a send from a request-resolved caller to a target peer and deliver it.
  *  hit (live)  → build envelope from the CALLER → deliverViaTmux → {woke:false}
@@ -529,6 +569,12 @@ export async function routeSend(
     return err(`peer "${personality}" is not in the iapeer peers index; message NOT delivered`)
   }
 
+  // Telegram sender policy — INTENDED channel (explicit override, or the target's
+  // default). Checked BEFORE any wake side-effect: a wake delivers the envelope as
+  // the boot first-message, past the resolved-target guards further down.
+  const intendedGuard = telegramSenderGuard(caller, runtime ?? peer.runtime, personality)
+  if (!intendedGuard.ok) return intendedGuard
+
   // Built once — it is both the live-delivery payload and, on a miss, the wake
   // first-message (the woken session receives it as its boot task).
   const envelope = buildEnvelope({
@@ -554,6 +600,10 @@ export async function routeSend(
   const target = resolvePeerDeliveryTarget(personality, runtime, peer)
   if (target.ok) {
     if (target.value.address === caller.address) return err('cannot send to self')
+    // Telegram sender policy — RESOLVED channel (the only-live-session fallback can
+    // land on telegram without an override and without telegram being the default).
+    const liveGuard = telegramSenderGuard(caller, target.value.runtime, personality)
+    if (!liveGuard.ok) return liveGuard
     // peer.cwd enables the Ф-B transcript-mtime liveness probe (busy-session case).
     const delivered = deliverViaTmux(target.value, envelope, peer.cwd)
     if (!delivered.ok) return delivered
@@ -581,6 +631,11 @@ export async function routeSend(
     return err(`woke "${personality}" but the session is not live (verify-before-act): ${live.error.message}`)
   }
   if (live.value.address === caller.address) return err('cannot send to self')
+  // Telegram sender policy — post-wake RESOLVED channel (airtight: a wake should
+  // never bring up a telegram session — they are launchd-held — but the policy is
+  // enforced on every delivery point, not on an assumption about the wake).
+  const postWakeGuard = telegramSenderGuard(caller, live.value.runtime, personality)
+  if (!postWakeGuard.ok) return postWakeGuard
   // taskDelivered:false — the wake took the idempotent live-session fast path (a
   // CONCURRENT sender's boot won the wake.lock and delivered only ITS envelope as
   // the boot first-message). OUR envelope was not delivered by anything yet —

package/src/transport/routesend-wake.test.ts

@@ -17,7 +17,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
 import { spawnSync } from 'child_process'
-import { routeSend, type WakeFn } from './index.ts'
+import { hasTelegramPresence, routeSend, type WakeFn } from './index.ts'
 import type { ResolvedCaller } from '../identity/index.ts'
 import type { PeerRecord } from '../registry/index.ts'
 
@@ -48,6 +48,10 @@ const callerRecord = {
   description: '',
   intelligence: 'artificial',
   cwd: '/tmp/boris',
+  // Telegram sender policy: the target of these suites is a telegram peer, so the
+  // caller must declare a telegram presence (the bot machine-key) — these suites
+  // double as the "bot-faced sender delivers as before" half of the policy criterion.
+  interfaces: { telegram: { bot: 'boris' } },
 } as unknown as PeerRecord
 const caller: ResolvedCaller = {
   personality: 'boris',
@@ -213,3 +217,89 @@ describe.if(tmuxAvailable)('routeSend noteLiveTopic seam (live-delivered topic)'
     killTargetSession()
   })
 })
+
+// ─── Telegram sender policy (defect track 11.06) ─────────────────────────────
+// A sender with NO declared telegram presence (interfaces.telegram.bot|user_id)
+// must get a SYNCHRONOUS refusal when the delivery channel is telegram — the
+// incident class: the bridge silently dropped such envelopes while the router
+// reported ok:true. The bot-faced "delivers as before" half of the criterion is
+// carried by the suites above (their caller declares interfaces.telegram.bot).
+
+const facelessCaller: ResolvedCaller = {
+  personality: 'ghost',
+  runtime: 'claude',
+  address: 'claude-ghost',
+  description: '',
+  intelligence: 'artificial',
+  cwd: '/tmp/ghost',
+  record: {
+    personality: 'ghost',
+    runtime: 'claude',
+    runtimes: ['claude'],
+    description: '',
+    intelligence: 'artificial',
+    cwd: '/tmp/ghost',
+  } as unknown as PeerRecord,
+}
+
+describe('telegram sender policy — hasTelegramPresence', () => {
+  const rec = (tg: unknown): PeerRecord =>
+    ({ personality: 'x', runtime: 'claude', runtimes: ['claude'], description: '', intelligence: 'artificial', cwd: '/tmp/x', ...(tg !== undefined ? { interfaces: { telegram: tg } } : {}) }) as unknown as PeerRecord
+  test('bot machine-key (agent peers) → sender face present', () => {
+    expect(hasTelegramPresence(rec({ bot: 'boris' }))).toBe(true)
+  })
+  test('user_id alone (natural peers — arthur) → NO sender face: the bridge sends FROM the bot key; user_id is a receive/operator identity (owner fact, bot-only predicate)', () => {
+    expect(hasTelegramPresence(rec({ user_id: '409502965' }))).toBe(false)
+    expect(hasTelegramPresence(rec({ user_id: 409502965 }))).toBe(false)
+  })
+  test('no interfaces / no telegram / empty bot → absent', () => {
+    expect(hasTelegramPresence(rec(undefined))).toBe(false)
+    expect(hasTelegramPresence(rec({}))).toBe(false)
+    expect(hasTelegramPresence(rec({ bot: '' }))).toBe(false)
+    expect(hasTelegramPresence(rec({ bot: '  ' }))).toBe(false)
+    expect(hasTelegramPresence(rec({ aliases: { '/alias-new': 'x' } }))).toBe(false)
+  })
+})
+
+describe('telegram sender policy — routeSend refusal', () => {
+  test('INTENDED channel (target default = telegram, peer offline): refused BEFORE the wake — wake never invoked', async () => {
+    let wakeCalled = false
+    const wake: WakeFn = async () => {
+      wakeCalled = true
+      return { status: 'READY', woke: true, runtime: 'telegram', taskDelivered: true }
+    }
+    const r = await routeSend(facelessCaller, { personality: TARGET, message: 'm' }, { wake })
+    expect(r.ok).toBe(false)
+    if (!r.ok) {
+      expect(r.error.message).toContain('telegram policy')
+      expect(r.error.message).toContain('"ghost"')
+      expect(r.error.message).toContain('NOT delivered')
+    }
+    expect(wakeCalled).toBe(false)
+  })
+
+  test('explicit runtime=telegram override: refused with the policy line, not "offline"', async () => {
+    const r = await routeSend(facelessCaller, { personality: TARGET, runtime: 'telegram', message: 'm' })
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.error.message).toContain('telegram policy')
+  })
+})
+
+describe.if(tmuxAvailable)('telegram sender policy — live telegram session', () => {
+  test('faceless sender + LIVE telegram target → refused, envelope NEVER reaches the pane', async () => {
+    startTargetSession()
+    const r = await routeSend(facelessCaller, { personality: TARGET, message: 'POLICY-MUST-BLOCK' })
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.error.message).toContain('telegram policy')
+    expect(capturePane()).not.toContain('POLICY-MUST-BLOCK')
+    killTargetSession()
+  })
+
+  test('bot-faced sender (boris) + LIVE telegram target → delivered as before', async () => {
+    startTargetSession()
+    const r = await routeSend(caller, { personality: TARGET, message: 'BOT-FACED-OK' })
+    expect(r.ok).toBe(true)
+    expect(capturePane()).toContain('BOT-FACED-OK')
+    killTargetSession()
+  })
+})