@agfpd/iapeer 0.2.75 → 0.2.76

package/package.json

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

package/src/daemon/daemon.test.ts

@@ -73,12 +73,19 @@ describe('caller identity from header', () => {
 })
 
 describe('listTools', () => {
-  test('serves ONLY send_to_peer (list_online_peers deprecated) with alwaysLoad meta and roster', () => {
-    const tools = listTools(readPeersIndex()) as any[]
+  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')
-    expect(sendTool.description).toContain('arthur')
+    // 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')

package/src/daemon/index.ts

@@ -41,7 +41,7 @@ import {
 import { parseSessionName } from '../core/socket.ts'
 import { IapError } from '../core/errors.ts'
 import { pluginStateDir, writeFileAtomic, type StorageOptions } from '../storage/index.ts'
-import { publicPeerSummary, readPeersIndex, type PeersIndex } from '../registry/index.ts'
+import { readPeersIndex, type PeersIndex } from '../registry/index.ts'
 import { resolveCallerIdentity, type CallerIdentity, type ResolvedCaller } from '../identity/index.ts'
 import { routeSend, type ComposerQueueRouteDeps, type EphemeralRouteDeps, type SendToPeerInput, type WakeFn } from '../transport/index.ts'
 import { appendDeliveryEvent } from './deliverylog.ts'
@@ -76,31 +76,22 @@ export function resolveCallerFromHeader(value: string | undefined, index: PeersI
 // Tool definitions (ported verbatim from IAP server.ts)
 // ─────────────────────────────────────────────────────────────────────────────
 
-export function buildSendDescription(index: PeersIndex): string {
-  const lines = [
+// The roster of known peers is DELIBERATELY NOT in this description. It is rendered
+// ONCE, in the peer's system prompt (composeSystemPrompt → Layer 3 "## Known peers").
+// Embedding it here ALSO duplicated the full list into every agent's context on every
+// turn — a live consumer (boris) confirmed seeing the identical roster twice. The
+// description stays light: purpose + parameter semantics only; the model gets the
+// roster from its system prompt. Likewise the MCP server-level `instructions` field is
+// left unset (createMcpServer) — it would re-inject doctrine into the client system
+// prompt, re-creating the very duplication this removed. Static (no index needed).
+export function buildSendDescription(): string {
+  return [
     'Send a message to a known iapeer peer through Inter-Agent-Protocol.',
     'Peers can be agents, humans, or services. Runtime is the delivery surface, not the peer type.',
     'Current delivery supports any runtime endpoint that follows the IAP tmux socket convention. Claude/Codex are built-in local runtimes; external runtimes such as telegram can be exposed by runtime-router packages.',
     '',
-    'Known peers on this host:',
-  ]
-  if (index.peers.length === 0) {
-    lines.push('- none yet')
-  } else {
-    for (const peer of index.peers) {
-      const p = publicPeerSummary(peer)
-      const desc = p.description ? ` — ${p.description}` : ''
-      lines.push(`- ${p.personality}${desc}`)
-      lines.push(`  Runtime: ${p.runtime}`)
-      lines.push(`  Runtimes: ${p.runtimes.join(', ')}`)
-      lines.push(`  Intelligence: ${p.intelligence}`)
-    }
-  }
-  lines.push(
-    '',
-    "Use `personality`, not a runtime-prefixed identity. Set `runtime` to target a specific declared runtime for this send. If that runtime is warm-asleep, the daemon wakes it and delivers there; use this to intentionally bring up a second session of the same peer in parallel to the default runtime (for example codex alongside claude). Descriptions identify the peer's role; runtimes identify reachable delivery endpoints; intelligence identifies the nature of the peer (artificial / natural / absent). Inbound peer messages arrive as <iap from-personality=\"...\" from-runtime=\"...\" from-intelligence=\"...\"> blocks. The topic attribute is optional.",
-  )
-  return lines.join('\n')
+    "Use `personality`, not a runtime-prefixed identity. Set `runtime` to target a specific declared runtime for this send. If that runtime is warm-asleep, the daemon wakes it and delivers there; use this to intentionally bring up a second session of the same peer in parallel to the default runtime (for example codex alongside claude). Inbound peer messages arrive as <iap from-personality=\"...\" from-runtime=\"...\" from-intelligence=\"...\"> blocks. The topic attribute is optional.",
+  ].join('\n')
 }
 
 // The daemon serves the AGENT exactly ONE MCP tool: send_to_peer. list_online_peers
@@ -110,11 +101,11 @@ export function buildSendDescription(index: PeersIndex): string {
 // tool-set is kept minimal. The liveness scan itself (transport.listOnlinePeers) stays
 // — the future `iapeer list` verb and the multi-runtime delivery resolver use it — it
 // is simply no longer exposed to the agent as a tool.
-export function listTools(index: PeersIndex): unknown[] {
+export function listTools(): unknown[] {
   return [
     {
       name: 'send_to_peer',
-      description: buildSendDescription(index),
+      description: buildSendDescription(),
       inputSchema: {
         type: 'object',
         properties: {
@@ -270,7 +261,7 @@ function headerFromRequestInfo(extra: { requestInfo?: { headers?: Record<string,
 export function createMcpServer(deps: CallToolDeps = {}): Server {
   const server = new Server(SERVER_INFO, { capabilities: { tools: {} } })
 
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: listTools(readPeersIndex()) }))
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: listTools() }))
 
   server.setRequestHandler(CallToolRequestSchema, async (req, extra): Promise<CallToolResult> => {
     // Per-request identity: read the caller from THIS request's HTTP header,

package/src/launch/adapters/claude.ts

@@ -223,26 +223,6 @@ export const claudeAdapter: RuntimeAdapter = {
     return newest > 0 ? newest : null
   },
 
-  /**
-   * A claude tool-permission/approval modal is open iff the pane shows
-   * 'Do you want to proceed?' (Spawned-Peer dialogs.ts:60-61,
-   * approve-watch.sh:78). Defensive only: a --dangerously-skip-permissions peer
-   * does not normally reach it, but a stray approval (e.g. a connector) must not
-   * stall a headless session.
-   */
-  permissionDialogActive(pane: string): boolean {
-    return pane.includes('Do you want to proceed?')
-  },
-
-  /**
-   * Affirm a claude approval with ['Enter']: option 1 ('Yes') is the
-   * default-highlighted choice, so a bare Enter accepts (approve-watch.sh:22-25,
-   * Spawned-Peer watcher.ts:298).
-   */
-  permissionDialogKeys(): string[] {
-    return ['Enter']
-  },
-
   /**
    * Resume preflight (fail-loud — never a silent fresh fallback): resolve the
    * newest transcript uuid for cwd via the claude-slug dir scan (lifecycle.

package/src/launch/adapters/codex.ts

@@ -260,35 +260,6 @@ export const codexAdapter: RuntimeAdapter = {
     return newestCodexSessionMtime(cwd)
   },
 
-  /**
-   * A codex approval modal is open iff the pane carries the 'enter to submit'
-   * footer AND an Allow-to-run title — the MCP tool-approval modal ("Allow the
-   * <server> MCP server to run tool …?") or the generic command-exec approval
-   * (dialogs.ts codexApprovalActive, 39-45). The footer is the discriminator
-   * against boot-phase startup screens (those say 'Press enter to continue'), so
-   * a dir-trust/update screen never matches here. Required even under YOLO:
-   * connector / consequential MCP-tool approvals are NOT suppressed by
-   * --dangerously-bypass-approvals-and-sandbox and would block a headless peer
-   * forever (codex-start.sh:229-237).
-   */
-  permissionDialogActive(pane: string): boolean {
-    if (!pane.includes('enter to submit')) return false
-    if (/Allow the .+ MCP server to run tool/.test(pane)) return true
-    return /\bAllow\b[\s\S]*\bto run\b/.test(pane)
-  },
-
-  /**
-   * Affirm a codex approval with ['Down','Enter'] (watcher.answerPermissionDialog
-   * codex branch, 302-306): the modal default-highlights option 1 ("Allow",
-   * one-shot); one Down selects option 2 ("Allow for this session") so later tool
-   * calls in this same headless session don't re-prompt, then Enter submits. Even
-   * partial key delivery is safe — Down-then-nothing leaves option 1 (still an
-   * affirmative), and the only destructive option (Cancel) is three Downs away.
-   */
-  permissionDialogKeys(): string[] {
-    return ['Down', 'Enter']
-  },
-
   /**
    * Resume preflight (fail-loud — never a silent fresh fallback). Codex resumes
    * via 'resume --last' with NO ref: it matches the newest session for cwd

package/src/launch/adapters/notifier.ts

@@ -68,16 +68,6 @@ export const notifierAdapter: RuntimeAdapter = {
     return null
   },
 
-  /** No permission/approval modal: a router is not an LLM driving tools. */
-  permissionDialogActive(_pane: string): boolean {
-    return false
-  },
-
-  /** No permission modal to affirm — empty send-keys args. */
-  permissionDialogKeys(): string[] {
-    return []
-  },
-
   /** Nothing to resume: a router does not replay a transcript. */
   resolveResume(_cwd: string): { ok: boolean; ref?: string; reason?: string } {
     return { ok: true }

package/src/launch/adapters/telegram.ts

@@ -98,20 +98,6 @@ export const telegramAdapter: RuntimeAdapter = {
     return null
   },
 
-  /**
-   * No permission/approval modal: a router is not an LLM driving tools behind an
-   * autopilot, so there is never a dialog to detect (telegram-start.sh:14, "no
-   * trust-dialog auto-accept, no permissions banner").
-   */
-  permissionDialogActive(_pane: string): boolean {
-    return false
-  },
-
-  /** No permission modal to affirm — empty send-keys args (see above). */
-  permissionDialogKeys(): string[] {
-    return []
-  },
-
   /**
    * Nothing to resume: a router does not replay a transcript, so resume cannot
    * fail-loud the way claude/codex do — there is no prior session ref to resolve

package/src/launch/bootdeliver.test.ts

@@ -50,8 +50,6 @@ function catAdapter(recvPath: string): RuntimeAdapter {
         return null
       }
     },
-    permissionDialogActive: () => false,
-    permissionDialogKeys: () => [],
     resolveResume: () => ({ ok: true }),
     executeControl: () => null,
   }

package/src/launch/launch.test.ts

@@ -136,7 +136,6 @@ describe('telegramAdapter (router — no TUI surface)', () => {
     expect(telegramAdapter.bootDialogKeys('anything')).toBeNull()
     expect(telegramAdapter.isInputReady('anything')).toBe(true)
     expect(telegramAdapter.newestActivityMtime('/w')).toBeNull()
-    expect(telegramAdapter.permissionDialogActive('x')).toBe(false)
   })
 })
 
@@ -156,8 +155,6 @@ describe('notifierAdapter (router — infra/always-on)', () => {
     expect(notifierAdapter.bootDialogKeys('anything')).toBeNull()
     expect(notifierAdapter.isInputReady('anything')).toBe(true)
     expect(notifierAdapter.newestActivityMtime('/w')).toBeNull()
-    expect(notifierAdapter.permissionDialogActive('x')).toBe(false)
-    expect(notifierAdapter.permissionDialogKeys()).toEqual([])
     expect(notifierAdapter.resolveResume('/w')).toEqual({ ok: true })
   })
 })
@@ -249,12 +246,6 @@ describe('claudeAdapter', () => {
       "This session is 7h 3m old and 314.2k tokens.\n❯ 1. Resume from summary (recommended)\n  2. Resume full session as-is\n  3. Don't ask me again\nEnter to confirm · Esc to cancel"
     expect(claudeAdapter.bootDialogKeys(live170)).toEqual(['Down'])
   })
-
-  test('permissionDialog: proceed prompt → active, [Enter]', () => {
-    expect(claudeAdapter.permissionDialogActive('Do you want to proceed?')).toBe(true)
-    expect(claudeAdapter.permissionDialogActive('nothing')).toBe(false)
-    expect(claudeAdapter.permissionDialogKeys()).toEqual(['Enter'])
-  })
 })
 
 // ─── exit-cause observability: the pane-died hook builder (pure string) ──────

package/src/launch/types.ts

@@ -265,12 +265,6 @@ export interface RuntimeAdapter {
    *  claude transcript / codex session jsonl mtime; null for a router (no proxy). */
   newestActivityMtime(cwd: string): number | null
 
-  /** Is a permission/approval dialog open in the pane (headless autopilot)? */
-  permissionDialogActive(pane: string): boolean
-  /** tmux send-keys args to affirm a permission dialog (claude ['Enter'];
-   *  codex ['Down','Enter'] to pick "allow for session"). */
-  permissionDialogKeys(): string[]
-
   /** Resume preflight — validate a resume request fail-loud (never silent fresh).
    *  Returns the resolved ref (claude uuid) or ok:false with a reason. */
   resolveResume(cwd: string): { ok: boolean; ref?: string; reason?: string }

package/src/lifecycle/index.ts

@@ -48,7 +48,7 @@ import {
 } from '../launch/index.ts'
 import { composeSystemPrompt, gatherPromptInput } from '../launch/composeSystemPrompt.ts'
 import { dismissCanary, ensureServerCanary, signalCanaryClean } from '../launch/canary.ts'
-import { hostSessionAlive, killPtyHost } from '../launch/ptyHost.ts'
+import { hostSessionAlive, killPtyHost, ptyHostEnabled } from '../launch/ptyHost.ts'
 import { appendLifecycleEvent, superviseLogVerbose } from './eventlog.ts'
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -668,10 +668,21 @@ function sessionAlive(sock: string, identity: string): boolean {
  *  - `server-dead` — the server itself is gone: the socket file is missing, or it
  *    exists but nothing serves it (stale socket — the SIGKILL/OOM class). pane-died
  *    could never fire; the server-death canary (launch/canary.ts) is the recorder
- *    for this class (`ev=server-exit` + forensics), this line is the backstop. */
-export function classifyGoneSession(sock: string): { death: 'server-dead' | 'session-gone'; reason: string } {
+ *    for this class (`ev=server-exit` + forensics), this line is the backstop.
+ *  `hosted=true` (pty-supervisor peer) reframes ONLY the absent-socket reason: a hosted peer
+ *  has NO tmux socket, so that branch would otherwise misattribute its death to a tmux server
+ *  that never existed. Its real cause lives in the supervisor exits.log. A socket that EXISTS
+ *  is a genuine tmux server, so `hosted` never overrides the session-gone / stale-socket arm. */
+export function classifyGoneSession(sock: string, hosted = false): { death: 'server-dead' | 'session-gone'; reason: string } {
   if (!existsSync(sock)) {
-    return { death: 'server-dead', reason: 'tmux server gone (socket file missing)' }
+    // No socket file. For a pty-supervisor-hosted peer this is EXPECTED — it never had a tmux
+    // socket; its death is the supervisor session ending (cause in the supervisor exits.log
+    // death-EVENT), NOT a tmux server vanishing. For a tmux peer it IS a dead tmux server.
+    // The check is gated on the absent socket on purpose: a socket that EXISTS (below) means a
+    // real tmux server, so `hosted` (pty-enabled-by-default) must not override genuine tmux.
+    return hosted
+      ? { death: 'server-dead', reason: 'pty host session ended (supervisor) — cause in exits.log (death-EVENT)' }
+      : { death: 'server-dead', reason: 'tmux server gone (socket file missing)' }
   }
   // Ask the SERVER, not the session: any server-level command answering (exit 0)
   // proves the server is alive and merely lost this session.
@@ -1172,7 +1183,7 @@ export function superviseTick(cfg: LifecycleConfig, deps: SuperviseDeps = {}): S
       // distinguishable in lifecycle.log: `session-gone` (pane died, server alive →
       // exits.log should have the cause) vs `server-dead` (whole tmux server died →
       // exits.log structurally empty; this line is the only durable trace).
-      const gone = classifyGoneSession(sock)
+      const gone = classifyGoneSession(sock, ptyHostEnabled(cfg.logDir, s.identity))
       out.push({ identity: s.identity, action: 'reaped-gone', reason: gone.reason })
       trace({ identity: s.identity, action: 'reaped-gone', death: gone.death, reason: gone.reason, outcome: 'fresh-next-msg' })
       continue

package/src/lifecycle/lifecycle.test.ts

@@ -738,6 +738,15 @@ describe('classifyGoneSession (death-class tag)', () => {
     expect(r.reason).toContain('socket file missing')
   })
 
+  test('hosted peer → host-framed reason, not tmux', () => {
+    // A pty-supervisor-hosted peer never had a tmux socket; the tmux-framed "socket file
+    // missing" would misattribute its death. hosted=true short-circuits to the supervisor framing.
+    const r = classifyGoneSession(join(tmpdir(), 'iapeer-no-such-sock-ever.sock'), true)
+    expect(r.death).toBe('server-dead')
+    expect(r.reason).toContain('pty host')
+    expect(r.reason).not.toContain('tmux server')
+  })
+
   test('stale socket (file exists, nothing serves it) → server-dead', () => {
     // The SIGKILL/OOM class: the killed server never unlinks its socket file.
     const dir = mkdtempSync(join(tmpdir(), 'iapeer-stale-sock-'))

package/src/supervisor/protocol.ts

@@ -78,7 +78,7 @@ export function stripQueries(s: string): string {
 // "looks right" table).
 //
 // tmux semantics mirrored for the vocabulary our RuntimeAdapters actually emit (bootDialogKeys /
-// permissionDialogKeys / executeControl): a leading `-l` switches to LITERAL mode (every following
+// executeControl): a leading `-l` switches to LITERAL mode (every following
 // token sent verbatim, no key-name lookup); otherwise each token is a KEY NAME when known, else
 // literal text. Cursor keys depend on DECCKM application-cursor-keys mode — `\x1b[B` (normal) vs
 // `\x1bOB` (application) — which tmux keys off the terminal mode and the caller reads from the

package/src/transport/index.ts

@@ -262,13 +262,6 @@ export function hasAttachedTmuxClient(target: DeliveryTarget): boolean {
   return r.out.split(/\r?\n/).map(line => line.trim()).includes(target.address)
 }
 
-export function targetComposerHasHumanInput(target: DeliveryTarget): boolean {
-  if (!isSupportedLocalRuntime(target.runtime)) return false
-  const cap = tmux(target.socketPath, 'capture-pane', '-e', '-p', '-t', target.address)
-  if (!cap.ok) return false
-  return composerCaptureHasHumanInput(cap.out, getAdapter(target.runtime).deliveryMarkers)
-}
-
 function targetComposerBlocksDelivery(target: DeliveryTarget): boolean {
   if (!isSupportedLocalRuntime(target.runtime)) return false
   const cap = tmux(target.socketPath, 'capture-pane', '-e', '-p', '-t', target.address)
@@ -1373,7 +1366,7 @@ function telegramSenderGuard(
 
 /**
  * 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}
+ *  hit (live)  → build envelope from the CALLER → deliverWarm (host-aware) → {woke:false}
  *  miss (dead) → if deps.wake: wake the peer (envelope = boot first-message) →
  *                verify-before-act re-resolve → {woke:true}; else explicit
  *                "offline" (Ф1 behaviour). H4 (don't wake launchd peers) and the