@agfpd/iapeer 0.2.74 → 0.2.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agfpd/iapeer",
-  "version": "0.2.74",
+  "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/compactDone.test.ts

@@ -2,7 +2,14 @@ import { describe, expect, test } from 'bun:test'
 import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync, appendFileSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
-import { compactDoneBaseline, compactTranscriptHasDone } from './index.ts'
+import { compactDoneBaseline, compactTranscriptHasDone, waitForCompactDone, type DeliveryTarget } from './index.ts'
+
+function claudeTarget(): DeliveryTarget {
+  return { runtime: 'claude', personality: 'tester', address: 'claude-tester', socketPath: '/tmp/iapeer-test-noop.sock' }
+}
+
+const CLAUDE_IDLE_PANE = '❯ \n bypass permissions on'
+const CLAUDE_BUSY_PANE = '· Compacting conversation… (esc to interrupt)\n  reloading context'
 
 function withHome(fn: (home: string, env: NodeJS.ProcessEnv) => void): void {
   const home = mkdtempSync(join(tmpdir(), 'iapeer-compact-gate-home-'))
@@ -58,3 +65,80 @@ describe('compact done transcript gate', () => {
     }
   }))
 })
+
+describe('waitForCompactDone — marker is authoritative, idle is a fast-path', () => {
+  function withClaudeMarker(
+    fn: (args: { cwd: string; env: NodeJS.ProcessEnv; writeMarker: () => void; baseline: ReturnType<typeof compactDoneBaseline> }) => void,
+  ): void {
+    withHome((home, env) => {
+      const cwd = mkdtempSync(join(tmpdir(), 'iapeer-compact-wait-cwd-'))
+      try {
+        const dir = join(home, '.claude', 'projects', claudeSlug(cwd))
+        mkdirSync(dir, { recursive: true })
+        const file = join(dir, 'session.jsonl')
+        writeFileSync(file, JSON.stringify({ type: 'user', message: { role: 'user', content: 'hi' } }) + '\n')
+        const baseline = compactDoneBaseline('claude', cwd, { env })
+        const writeMarker = () =>
+          appendFileSync(file, JSON.stringify({ type: 'system', subtype: 'compact_boundary', compactMetadata: { durationMs: 140708, preTokens: 535706, postTokens: 12524 } }) + '\n')
+        fn({ cwd, env, writeMarker, baseline })
+      } finally {
+        rmSync(cwd, { recursive: true, force: true })
+      }
+    })
+  }
+
+  // THE FIX: a large-context session that auto-continues into a working turn after compact
+  // keeps the composer busy (never idle). The marker proves completion → SUCCESS, not failure.
+  test('marker seen + composer never idle → success on the marker (signal: transcript)', () => withClaudeMarker(({ cwd, env, writeMarker, baseline }) => {
+    writeMarker()
+    const r = waitForCompactDone(claudeTarget(), cwd, baseline, {
+      env,
+      timeoutMs: 5000,
+      pollMs: 5,
+      graceMs: 20,
+      seam: { sessionAlive: () => true, capturePane: () => CLAUDE_BUSY_PANE },
+    })
+    expect(r.ok).toBe(true)
+    if (r.ok) expect(r.value.signal).toBe('transcript')
+  }))
+
+  // Clean common case unchanged: marker + idle composer → the historical 'transcript+ready'.
+  test('marker seen + composer idle → fast-path success (signal: transcript+ready)', () => withClaudeMarker(({ cwd, env, writeMarker, baseline }) => {
+    writeMarker()
+    const r = waitForCompactDone(claudeTarget(), cwd, baseline, {
+      env,
+      timeoutMs: 5000,
+      pollMs: 5,
+      graceMs: 5000,
+      seam: { sessionAlive: () => true, capturePane: () => CLAUDE_IDLE_PANE },
+    })
+    expect(r.ok).toBe(true)
+    if (r.ok) expect(r.value.signal).toBe('transcript+ready')
+  }))
+
+  // BOUNDARY preserved: no structured marker ever → honest failure (hung / never completed).
+  test('no marker → honest failure', () => withClaudeMarker(({ cwd, env, baseline }) => {
+    const r = waitForCompactDone(claudeTarget(), cwd, baseline, {
+      env,
+      timeoutMs: 40,
+      pollMs: 5,
+      graceMs: 20,
+      seam: { sessionAlive: () => true, capturePane: () => CLAUDE_BUSY_PANE },
+    })
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.error.message).toContain('no transcript compact marker')
+  }))
+
+  // Session death during the wait still fails (liveness boundary).
+  test('session vanished → failure', () => withClaudeMarker(({ cwd, env, baseline }) => {
+    const r = waitForCompactDone(claudeTarget(), cwd, baseline, {
+      env,
+      timeoutMs: 5000,
+      pollMs: 5,
+      graceMs: 20,
+      seam: { sessionAlive: () => false, capturePane: () => CLAUDE_BUSY_PANE },
+    })
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.error.message).toContain('session vanished')
+  }))
+})

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)
@@ -603,7 +596,23 @@ export interface CompactDoneBaseline {
 export interface CompactDoneWaitResult {
   ok: true
   ms: number
-  signal: 'transcript+ready'
+  /** How completion was confirmed:
+   *   'transcript+ready' — marker seen AND the composer returned to idle (the clean,
+   *       common case: a small/medium compact that settles back to the prompt).
+   *   'transcript' — marker seen but the composer is still BUSY past the ready-grace
+   *       (a large-context session that auto-continues into a working turn right after
+   *       compact). The structured marker is the AUTHORITATIVE completion signal, so this
+   *       is SUCCESS, not a timeout. */
+  signal: 'transcript+ready' | 'transcript'
+}
+
+/** Test seam for waitForCompactDone — inject the tmux liveness + pane capture so the
+ *  marker/grace logic is covered hermetically (no live session). Omitting all = prod. */
+export interface CompactDoneWaitSeam {
+  /** Is the target session still alive? Default: the real tmux/host sessionAlive. */
+  sessionAlive?: (target: DeliveryTarget) => boolean
+  /** Capture the target pane; null = capture failed. Default: real tmux capture-pane. */
+  capturePane?: (target: DeliveryTarget) => string | null
 }
 
 function envHome(env: NodeJS.ProcessEnv | undefined): string {
@@ -763,41 +772,97 @@ function compactDonePollMs(env: NodeJS.ProcessEnv | undefined): number {
   return Number.isFinite(n) && n > 0 ? n : 1000
 }
 
+// Once the completion marker is seen, how long to keep PREFERRING the idle-composer
+// confirmation (the clean 'transcript+ready' signal) before reporting success on the
+// marker alone. A large-context session that auto-continues into a working turn never
+// goes idle — this bounds how long we wait for an idle that may never come, so the
+// busy case succeeds promptly instead of stalling to the overall deadline. Short by
+// design; the marker is already authoritative.
+function compactReadyGraceMs(env: NodeJS.ProcessEnv | undefined): number {
+  const raw = env?.IAPEER_COMPACT_READY_GRACE_MS
+  const n = raw === undefined ? NaN : Number(raw)
+  return Number.isFinite(n) && n >= 0 ? n : 5000
+}
+
 /**
  * Wait until a slash-/compact command has actually FINISHED, not merely until its
- * keystrokes were accepted. The primary signal is scroll-proof structured
- * transcript state written by the runtimes: Codex `context_compacted`, Claude
- * `compact_boundary`. The final input-ready check prevents a marker-only early
- * return while the TUI is still transitioning back to the composer/prompt.
+ * keystrokes were accepted. The AUTHORITATIVE signal is scroll-proof structured
+ * transcript state written by the runtimes at the END of the operation (with post-
+ * compact token metadata): Codex `context_compacted`, Claude `compact_boundary`.
+ * Once that marker is present the compact objectively completed.
+ *
+ * Idle-composer (`isInputReady`) is treated as a FAST-PATH confirmation, NOT a
+ * requirement. A healthy large-context session auto-continues into a working turn
+ * right after compact — its composer is legitimately busy (not idle) for a while, so
+ * requiring idle here false-failed a finished compact (live incident 15.06, boris:
+ * marker at 12:14:58, first post-compact idle only ~232s later, past the ~290s gate).
+ * Therefore: marker seen + composer idle → 'transcript+ready' (clean); marker seen +
+ * composer still busy past a short grace → 'transcript' (busy-but-done, still SUCCESS).
+ *
+ * BOUNDARY (preserved): a compact whose structured marker NEVER appears still fails
+ * honestly — that is the genuine "hung / never completed" case. Cross-runtime: the
+ * marker set + isInputReady are both per-adapter, so claude and codex share this path.
  */
 export function waitForCompactDone(
   target: DeliveryTarget,
   cwd: string,
   baseline: CompactDoneBaseline,
-  opts: { env?: NodeJS.ProcessEnv; timeoutMs?: number; pollMs?: number } = {},
+  opts: {
+    env?: NodeJS.ProcessEnv
+    timeoutMs?: number
+    pollMs?: number
+    graceMs?: number
+    seam?: CompactDoneWaitSeam
+  } = {},
 ): Result<CompactDoneWaitResult> {
   const env = opts.env ?? process.env
   const timeoutMs = opts.timeoutMs ?? compactDoneTimeoutMs(env)
   const pollMs = opts.pollMs ?? compactDonePollMs(env)
+  const graceMs = opts.graceMs ?? compactReadyGraceMs(env)
+  const aliveFn = opts.seam?.sessionAlive ?? ((t: DeliveryTarget) => sessionAlive(t.socketPath, t.address))
+  const captureFn =
+    opts.seam?.capturePane ??
+    ((t: DeliveryTarget) => {
+      const cap = tmux(t.socketPath, 'capture-pane', '-p', '-t', t.address)
+      return cap.ok ? cap.out : null
+    })
   const adapter = getAdapter(target.runtime)
   const started = monotonicMs()
   const deadline = started + timeoutMs
   let sawTranscriptDone = false
+  let markerSeenAtMs = -1
   let lastPane = ''
 
   do {
-    if (!sessionAlive(target.socketPath, target.address)) {
+    if (!aliveFn(target)) {
       return err(`compact did not complete: tmux session vanished`)
     }
-    sawTranscriptDone ||= compactTranscriptHasDone(baseline, { env })
-    const pane = tmux(target.socketPath, 'capture-pane', '-p', '-t', target.address)
-    if (pane.ok) lastPane = pane.out
-    if (sawTranscriptDone && pane.ok && adapter.isInputReady(pane.out)) {
-      return ok({ ok: true, ms: monotonicMs() - started, signal: 'transcript+ready' })
+    if (!sawTranscriptDone && compactTranscriptHasDone(baseline, { env })) {
+      sawTranscriptDone = true
+      markerSeenAtMs = monotonicMs()
+    }
+    const pane = captureFn(target)
+    if (pane !== null) lastPane = pane
+    if (sawTranscriptDone) {
+      // Fast clean path: the composer returned to idle (the historical signal).
+      if (pane !== null && adapter.isInputReady(pane)) {
+        return ok({ ok: true, ms: monotonicMs() - started, signal: 'transcript+ready' })
+      }
+      // Marker is authoritative: a busy composer after a held marker is a healthy
+      // auto-continue, not a failure. Succeed on the marker once the grace elapses.
+      if (monotonicMs() - markerSeenAtMs >= graceMs) {
+        return ok({ ok: true, ms: monotonicMs() - started, signal: 'transcript' })
+      }
     }
     sleepSync(pollMs)
   } while (monotonicMs() < deadline)
 
+  // Deadline hit. The marker is authoritative: if it was EVER seen, the compact did
+  // finish — a still-busy composer at the deadline is not a failure (succeed on the
+  // marker). Only a MISSING marker is an honest failure (hung / never-completed compact).
+  if (sawTranscriptDone) {
+    return ok({ ok: true, ms: monotonicMs() - started, signal: 'transcript' })
+  }
   const tail = lastPane
     .split(/\r?\n/)
     .map(line => line.trim())
@@ -807,8 +872,7 @@ export function waitForCompactDone(
     .replace(/"/g, "'")
     .slice(0, 240)
   return err(
-    `compact did not complete within ${timeoutMs}ms (` +
-      `${sawTranscriptDone ? 'transcript marker seen, input not ready' : 'no transcript compact marker'}` +
+    `compact did not complete within ${timeoutMs}ms (no transcript compact marker` +
       `${tail ? `; pane tail: ${tail}` : ''})`,
   )
 }
@@ -1302,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